/
lasersquad
/
DynamicArrays
Обзор
Документация
Войти
/
lasersquad
/
DynamicArrays
Код
Задачи
Вики
Пакеты
0
Релизы
0
Аналитика
Безопасность
master
dynamicarrays/prj/Delphi/DynamicArraysOTests/DynamicArraysTHArrayTest.pas
2 187 строк
63 KB
lasersquad0
updated tests
20 май 2026, 23:22
20 май 2026, 23:22
5121364
Код
Авторство
О чём код?
unit DynamicArraysTHArrayTest; interface uses DUnitX.TestFramework, System.Generics.Defaults, {TestBase,} DynamicArrays; type [TestFixture] TDynamicArraysTHArrayTest<TTestArr: THArray> = class //(TTestBase) private type //TTestingArrayType = TTestArr; private FMyComparer: IComparer<TArray<Byte>>; // kind of static variable which saves its value between function calls } function FindProc(arr : THArray; i : Cardinal; FindData: Pointer): Integer; function Compare1(arr: THArray; i, j: Cardinal): Integer; function Compare2(Item1, Item2: TArray<Byte>): Integer; //function IsTTBoolean: Boolean; procedure VerifySorting(arr: TTestArr); procedure CopyArray(arr1, arr2: TTestArr); protected array1ItemSize: Integer; array2ItemSize: Integer; array1: TTestArr; array2: TTestArr; public [SetupFixture] procedure SetupFixture; // this method is called when all tests of this fixture are executed. so we have to free objects from FObjects [TearDownFixture] procedure TearDownFixture; // this method is called when all tests of this fixture are executed. so we have to free objects from FObjects [Setup] procedure Setup; [TearDown] procedure TearDown; [Test] procedure TestEmpty1; [Test] procedure TestEmpty2; [Test] procedure TestCountOne; [Test] procedure TestUpdate; [Test] procedure TestZero; [Test] procedure TestSwap; [Test] procedure TestAddFillValues; [Test] procedure TestIndexOF1; [Test] [TestCase('TestIndexofA','4, 1, 2, 0')] // last figure is used for asser�s when TTestArr=Boolean [TestCase('TestIndexofB','1,-1, 3, 0')] [TestCase('TestIndexofC','0, 3,-1, 1')] [TestCase('TestIndexofD','-13, 13, -1, 0')] procedure TestIndexOf2(const AValue1, AValue2, AValue3, AValue4: Integer); [Test] procedure TestCapacity1; [Test] procedure TestCapacity2; [Test] [TestCase('TestA','5,1')] [TestCase('TestB','4,3')] [TestCase('TestD','0,-1')] procedure TestAddTwoDiff(const AValue1, AValue2 : Integer); [Test] [TestCase('TestA','11, 11')] [TestCase('TestB',' 3999,3999')] [TestCase('TestC',' 0, 0')] [TestCase('TestD','00000000, 0000000')] procedure TestAddTwoEqual(const AValue1, AValue2 : Integer); [Test] procedure TestGrow; [Test] procedure TestInsert1; [Test] procedure TestInsert2; [Test] procedure TestDeleteValue1; [Test] procedure TestDeleteValue2; [Test] procedure TestAddClearAdd1; [Test] procedure TestAddClearAdd2; [Test] procedure TestSort1; [Test] procedure TestSort11; [TestCase('TestA', '1;2;3;4;5, 1;2;3;4;5')] [TestCase('TestB', '5;4;3;2;1, 1;2;3;4;5')] [TestCase('TestC', '44;53;1;12;100;999;9, 1;9;12;44;53;100;999')] [TestCase('TestD', '44;44;44;44;44;44;9, 9;44;44;44;44;44;44')] [TestCase('TestE', '9;1;9;1;9;1;9;1, 1;1;1;1;;9;9;9;9;;')] [TestCase('TestF', '15, 15')] [TestCase('TestG', '0, 0')] [TestCase('TestH', '0;0, 0;0')] [TestCase('TestK', '16;15, 15;16')] procedure TestSort2(AValue1, AValue2: string); [Test] procedure TestQuickSort1; // <unsorted items> , <sorted items to verify> [TestCase('TestA', '1;2;3;4;5, 1;2;3;4;5')] [TestCase('TestB', '5;4;3;2;1, 1;2;3;4;5')] [TestCase('TestC', '44;53;1;12;100;999;9, 1;9;12;44;53;100;999')] [TestCase('TestD', '44;44;44;44;44;44;9, 9;44;44;44;44;44;44')] [TestCase('TestE', '9;1;9;1;9;1;9;1, 1;1;1;1;;9;9;9;9;;')] [TestCase('TestF', '15, 15')] [TestCase('TestG', '0, 0')] [TestCase('TestH', '0;0, 0;0')] [TestCase('TestK', '16;15, 15;16')] procedure TestQuickSort2(AValue1, AValue2: string); [Test] procedure TestAddMany; [Test] procedure TestInsertMany; { [Test] [Ignore('Ignore this test to save testing time')] procedure TestQuickSortPerformance; [Test] [Ignore('Ignore this test to save testing time')] procedure TestSelectionSortPerformance; [Test] [Ignore('Ignore this test to save testing time')] procedure TestShakerSortPerformance; [Test] [Ignore('Ignore this test to save testing time')] procedure TestInsertionSortPerformance; [Test] // [MaxTime(5000)] [Ignore('Ignore this test to save testing time')] procedure TestBubbleSortPerformance; } [Test] //[Ignore('Ignore this test to save testing time')] procedure TestAllSortAlgsPerformance; // the same data array is sorted by 5 different sorting algs, time is measured // <unsorted items> , <value to find> , <value index to verify> [TestCase('TestA1', '1;2;3;4;5, 1 , 0')] [TestCase('TestA2', '1;2;3;4;5, 2 , 1')] [TestCase('TestA3', '1;2;3;4;5, 0 , -1')] [TestCase('TestA4', '5;4;3;2;1, 3 , 2')] [TestCase('TestA5', '5;4;3;2;1, 6 , -6')] [TestCase('TestA6', '5;4;3;2;1, 5 , 4')] [TestCase('TestA7', '5;4;3;2;1, 4 , 3')] [TestCase('TestA8', '5;4;3;2;6;1, 6 , 5')] [TestCase('TestC1', '44;53;1;12;100;109;9, 100, 5 ')] [TestCase('TestC2', '44;53;1;12;100;109;9, 109, 6 ')] [TestCase('TestC3', '44;53;1;12;100;109;9, 1000, -8 ')] [TestCase('TestD1', '44;44;44;44;44;44;9, 9 , 0 ')] [TestCase('TestD2', '44;44;44;44;44;44;9, 44 , 1 ')] [TestCase('TestD3', '44;44;44;44;44;44;9, 0 , -1 ')] [TestCase('TestE1', '9;1;9;1;9;1;9;1, 1, 0')] [TestCase('TestE2', '9;1;9;1;9;1;9;1, 9, 4')] [TestCase('TestE3', '9;1;9;1;9;1;9;1, 10, -9')] [TestCase('TestH', '15, 15, 0')] [TestCase('TestK1', '0, 0, 0')] [TestCase('TestK2', '0, 1, -2')] [TestCase('TestL1', '0;0, 0, 0')] [TestCase('TestL2', '0;0, -1, -3')] // this is because comparing in THarray is done per byte basis $FF is greater than 0 [TestCase('TestM', '16;15, 16, 1')] //[Ignore('temporary IMGORE')] [Category('QuickFindTests')] procedure TestQuickFind(AValue1, AValue2, AValue3: string); end; const ARRAYSIZE_FOR_SORTING = 25_000; implementation uses System.TypInfo, SysUtils, Winapi.Windows, Math, DynamicArraysUtils; procedure TDynamicArraysTHArrayTest<TTestArr>.SetupFixture; begin FMyComparer := nil; end; procedure TDynamicArraysTHArrayTest<TTestArr>.TearDownFixture; begin //FreeTObjects; end; procedure TDynamicArraysTHArrayTest<TTestArr>.Setup; begin array1ItemSize := 6; // need to fit to integer value at least array2ItemSize := 10; array1 := TTestArr.Create; array1.ItemSize := array1ItemSize; array2 := TTestArr.Create; array2.ItemSize := array2ItemSize; end; procedure TDynamicArraysTHArrayTest<TTestArr>.TearDown; begin FreeAndNil(array1); FreeAndNil(array2); end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestEmpty1; begin Assert.AreEqual(0, array1.Count); Assert.AreEqual(0, array1.Capacity); Assert.AreEqual(Cardinal(array1ItemSize), array1.ItemSize); array1.Clear(); Assert.AreEqual(0, array1.Count); Assert.AreEqual(0, array1.Capacity); Assert.AreEqual(Cardinal(array1ItemSize), array1.ItemSize); array1.ClearMem(); Assert.AreEqual(0, array1.Count); Assert.AreEqual(0, array1.Capacity); Assert.AreEqual(Cardinal(array1ItemSize), array1.ItemSize); array1.Hold; Assert.AreEqual(0, array1.Count); Assert.AreEqual(0, array1.Capacity); Assert.AreEqual(Cardinal(array1ItemSize), array1.ItemSize); array1.Zero; Assert.AreEqual(0, array1.Count); Assert.AreEqual(0, array1.Capacity); Assert.AreEqual(Cardinal(array1ItemSize), array1.ItemSize); end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestEmpty2; var val: TArray<Byte>; begin SetLength(val, array1.ItemSize); Assert.WillRaise(procedure begin array1.Delete(0) end, ERangeError, 'd0'); Assert.WillRaise(procedure begin array1.Delete(1) end, ERangeError, 'd1'); Assert.WillRaise(procedure begin array1.Delete(2) end, ERangeError, 'd2'); Assert.WillRaise(procedure begin array1.Delete(10000) end, ERangeError, 'd10000'); Assert.WillRaise(procedure begin array1.GetAddr(0) end, ERangeError, 'g0'); Assert.WillRaise(procedure begin array1.GetAddr(1) end, ERangeError, 'g1'); Assert.WillRaise(procedure begin array1.GetAddr(2) end, ERangeError, 'g2'); Assert.WillRaise(procedure begin array1.GetAddr(10000) end, ERangeError, 'g10000'); Assert.WillRaise(procedure begin array1.Get(0, nil) end, EAssertionFailed, 'g0nil'); Assert.WillRaise(procedure begin array1.Get(1, nil) end, EAssertionFailed, 'g10000nil'); Assert.WillRaise(procedure begin array1.Get(2, nil) end, EAssertionFailed, 'g10000nil'); Assert.WillRaise(procedure begin array1.Get(10000, nil) end, EAssertionFailed, 'g10000nil'); Assert.WillRaise(procedure begin array1.Get(0, @val[0]) end, ERangeError, 'g0'); Assert.WillRaise(procedure begin array1.Get(1, @val[0]) end, ERangeError, 'g1'); Assert.WillRaise(procedure begin array1.Get(2, @val[0]) end, ERangeError, 'g2'); Assert.WillRaise(procedure begin array1.Get(10000, @val[0]) end, ERangeError, 'g10000'); Assert.WillRaise(procedure begin array1.Update(0, nil) end, ERangeError, 'u0'); Assert.WillRaise(procedure begin array1.Update(1, nil) end, ERangeError, 'u1'); Assert.WillRaise(procedure begin array1.Update(2, nil) end, ERangeError, 'u2'); Assert.WillRaise(procedure begin array1.Update(10000, nil) end, ERangeError, 'u10000'); Assert.WillRaise(procedure begin array1.Update(0, @val[0]) end, ERangeError, 'u0'); Assert.WillRaise(procedure begin array1.Update(1, @val[0]) end, ERangeError, 'u1'); Assert.WillRaise(procedure begin array1.Update(2, @val[0]) end, ERangeError, 'u2'); Assert.WillRaise(procedure begin array1.Update(10000, @val[0]) end, ERangeError, 'u10000'); Assert.WillNotRaise(procedure begin array1.UpdateMany(0, nil, 0) end); // when Count = 0 no exception raised for pValue=nil Assert.WillRaise(procedure begin array1.UpdateMany(0, nil, 1) end, EAssertionFailed, 'um0n1'); Assert.WillNotRaise(procedure begin array1.UpdateMany(1, nil, 0) end); Assert.WillRaise(procedure begin array1.UpdateMany(1, nil, 1) end, EAssertionFailed, 'um1n1'); Assert.WillRaise(procedure begin array1.UpdateMany(9, nil, 9) end, EAssertionFailed, 'um9n9'); Assert.WillNotRaise(procedure begin array1.UpdateMany(0, @val[0], 0) end, ERangeError, 'um0val0'); Assert.WillRaise(procedure begin array1.UpdateMany(0, @val[0], 1) end, ERangeError, 'um0val0'); Assert.WillRaise(procedure begin array1.UpdateMany(0, @val[0], 100) end, ERangeError, 'um0val0'); Assert.WillNotRaise(procedure begin array1.UpdateMany(1, @val[0], 0) end, ERangeError, 'um0val0'); Assert.WillRaise(procedure begin array1.UpdateMany(1, @val[0], 1) end, ERangeError, 'um0val0'); Assert.WillNotRaise(procedure begin array1.UpdateMany(2, @val[0], 0) end, ERangeError, 'um0val0'); Assert.WillRaise(procedure begin array1.UpdateMany(2, @val[0], 1) end, ERangeError, 'um0val0'); Assert.WillRaise(procedure begin array1.UpdateMany(2, @val[0], 2) end, ERangeError, 'u2val2'); Assert.WillRaise(procedure begin array1.UpdateMany(2, @val[0], 10000) end, ERangeError, 'u2'); Assert.WillRaise(procedure begin array1.UpdateMany(10000, @val[0], 10000) end, ERangeError, 'u10000'); end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestCountOne; var val, val2, valTmp: TArray<Byte>; begin SetLength(val, array1.ItemSize); SetLength(val2, array1.ItemSize); SetLength(valTmp, array1.ItemSize); val[0] := 6; val[1] := 6; val[2] := 6; val2[0] := 9; val2[1] := 9; val2[2] := 9; val2[3] := 9; array1.Add(@val[0]); Assert.AreEqual(1, array1.Count); Assert.AreEqual(4, array1.Capacity); Assert.WillRaise(procedure begin array1.Delete(1) end, ERangeError, 'd1'); Assert.AreEqual(1, array1.Count); Assert.AreEqual(4, array1.Capacity); Assert.WillRaise(procedure begin array1.Delete(2) end, ERangeError, 'd2'); Assert.AreEqual(1, array1.Count); Assert.AreEqual(4, array1.Capacity); Assert.WillRaise(procedure begin array1.Delete(10000) end, ERangeError, 'd10000'); Assert.AreEqual(1, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.Get(0, @valTmp[0]); Assert.AreEqual(val, valTmp); Assert.WillRaise(procedure begin array1.Get(1, @valTmp[0]) end, ERangeError, 'g1'); Assert.WillRaise(procedure begin array1.Get(2, @valTmp[0]) end, ERangeError, 'g2'); Assert.WillRaise(procedure begin array1.Get(10000, @valTmp[0]) end, ERangeError, 'g10000'); Assert.WillRaise(procedure begin array1.Get(1, nil) end, EAssertionFailed, 'g1'); Assert.WillRaise(procedure begin array1.Get(2, nil) end, EAssertionFailed, 'g2'); Assert.WillRaise(procedure begin array1.Get(10000, nil) end, EAssertionFailed, 'g10000'); Assert.AreEqual(1, array1.Count); Assert.AreEqual(4, array1.Capacity); Assert.WillNotRaiseAny(procedure begin array1.Update(0, @val2[0]) end); Assert.WillRaise(procedure begin array1.Update(1, @val2[0]) end, ERangeError, 'u1'); Assert.WillRaise(procedure begin array1.Update(2, @val2[0]) end, ERangeError, 'u2'); Assert.WillRaise(procedure begin array1.Update(10000, @val2[0]) end, ERangeError, 'u10000'); array1.Get(0, @valTmp[0]); Assert.AreEqual(val2, valTmp); end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestUpdate; var val, val2, val3, valTmp: TArray<Byte>; newVal0, newVal1, newVal2: TArray<Byte>; begin SetLength(val, array1.ItemSize); SetLength(val2, array1.ItemSize); SetLength(val3, array1.ItemSize); SetLength(valTmp, array1.ItemSize); SetLength(newVal0, array1.ItemSize); SetLength(newVal1, array1.ItemSize); SetLength(newVal2, array1.ItemSize); val[0] := 6; val[1] := 6; val[2] := 6; val2[0] := 9; val2[1] := 9; val2[2] := 9; val2[3] := 9; val3[0] := 1; val3[1] := 5; val3[2] := 0; val3[3] := 0; val3[4] := 3; array1.Insert(0, @val[0]); array1.Insert(1, @val2[0]); array1.Insert(2, @val3[0]); array1.Get(0, @valTmp[0]); Assert.AreEqual(val, valTmp); array1.Get(1, @valTmp[0]); Assert.AreEqual(val2, valTmp); array1.Get(2, @valTmp[0]); Assert.AreEqual(val3, valTmp); newVal0[0] := 1; newVal1[0] := 2; newVal1[1] := 2; newVal2[0] := 4; newVal2[1] := 4; newVal2[2] := 4; array1.Update(0, @newVal0[0]); array1.Get(0, @valTmp[0]); Assert.AreEqual(newVal0, valTmp); array1.Get(1, @valTmp[0]); Assert.AreEqual(val2, valTmp); array1.Get(2, @valTmp[0]); Assert.AreEqual(val3, valTmp); array1.Update(1, @newVal1[0]); array1.Get(0, @valTmp[0]); Assert.AreEqual(newVal0, valTmp); array1.Get(1, @valTmp[0]); Assert.AreEqual(newVal1, valTmp); array1.Get(2, @valTmp[0]); Assert.AreEqual(val3, valTmp); array1.Update(2, @newVal2[0]); array1.Get(0, @valTmp[0]); Assert.AreEqual(newVal0, valTmp); array1.Get(1, @valTmp[0]); Assert.AreEqual(newVal1, valTmp); array1.Get(2, @valTmp[0]); Assert.AreEqual(newVal2, valTmp); Assert.AreEqual(3, array1.Count); Assert.AreEqual(4, array1.Capacity); Assert.WillRaise(procedure begin array1.Update(3, @newVal0[0]) end, ERangeError, 'g1'); Assert.WillRaise(procedure begin array1.Update(4, @newVal0[0]) end, ERangeError, 'g2'); Assert.WillRaise(procedure begin array1.Update(1000, @newVal0[0]) end, ERangeError, 'g10000'); Assert.AreEqual(3, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.Update(1, nil); array1.Get(1, @valTmp[0]); PInteger(@newVal1[0])^ := 0; Assert.AreEqual(newVal1, valTmp); array1.Get(0, @valTmp[0]); Assert.AreEqual(newVal0, valTmp); array1.Get(2, @valTmp[0]); Assert.AreEqual(newVal2, valTmp); end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestZero; var val, val2, val3, valTmp: TArray<Byte>; newVal: TArray<Byte>; i: Integer; begin Assert.AreEqual(0, array1.Count); Assert.AreEqual(0, array1.Capacity); array1.Zero; Assert.AreEqual(0, array1.Count); Assert.AreEqual(0, array1.Capacity); SetLength(valTmp, array1.ItemSize); SetLength(newVal, array1.ItemSize); SetLength(val, array1.ItemSize); SetLength(val2, array1.ItemSize); SetLength(val3, array1.ItemSize); PInteger(@val[0])^ := 666; PInteger(@val2[0])^ := 9999; PInteger(@val3[0])^ := 15003; array1.Insert(0, @val[0]); array1.Insert(1, @val2[0]); array1.Insert(2, @val3[0]); Assert.AreEqual(3, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.Get(0, @valTmp[0]); Assert.AreEqual(val, valTmp); array1.Get(1, @valTmp[0]); Assert.AreEqual(val2, valTmp); array1.Get(2, @valTmp[0]); Assert.AreEqual(val3, valTmp); array1.Zero; Assert.AreEqual(3, array1.Count); Assert.AreEqual(4, array1.Capacity); PInteger(@newVal[0])^ := 0; array1.Get(0, @valTmp[0]); Assert.AreEqual(newVal, valTmp); array1.Get(1, @valTmp[0]); Assert.AreEqual(newVal, valTmp); array1.Get(2, @valTmp[0]); Assert.AreEqual(newVal, valTmp); PInteger(@val[0])^ := 1; PInteger(@val2[0])^ := 22; PInteger(@val3[0])^ := 444; array1.Insert(1, @val[0]); array1.Get(1, @valTmp[0]); Assert.AreEqual(val, valTmp); array1.Insert(3, @val2[0]); array1.Get(3, @valTmp[0]); Assert.AreEqual(val2, valTmp); array1.Insert(5, @val3[0]); array1.Get(5, @valTmp[0]); Assert.AreEqual(val3, valTmp); array1.Zero; PInteger(@newVal[0])^ := 0; for i := 0 to 5 do begin array1.Get(i, @valTmp[0]); Assert.AreEqual(newVal, valTmp); end; Assert.AreEqual(6, array1.Count); Assert.AreEqual(8, array1.Capacity); end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestSwap; var val0, val1, val2, valTmp: TArray<Byte>; begin SetLength(val0, array1.ItemSize); SetLength(val1, array1.ItemSize); SetLength(val2, array1.ItemSize); SetLength(valTmp, array1.ItemSize); val0[0] := 6; val0[1] := 6; val0[2] := 6; val1[0] := 9; val1[1] := 9; val1[2] := 9; val1[3] := 9; val2[0] := 1; val2[1] := 5; val2[2] := 0; val2[3] := 0; val2[3] := 3; array1.Insert(0, @val0[0]); array1.Insert(1, @val1[0]); array1.Add(@val2[0]); Assert.AreEqual(3, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.Get(0, @valTmp[0]); Assert.AreEqual(val0, valTmp); array1.Get(1, @valTmp[0]); Assert.AreEqual(val1, valTmp); array1.Get(2, @valTmp[0]); Assert.AreEqual(val2, valTmp); array1.Swap(0, 1); Assert.AreEqual(3, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.Get(0, @valTmp[0]); Assert.AreEqual(val1, valTmp); array1.Get(1, @valTmp[0]); Assert.AreEqual(val0, valTmp); array1.Get(2, @valTmp[0]); Assert.AreEqual(val2, valTmp); array1.Swap(0, 1); Assert.AreEqual(3, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.Get(0, @valTmp[0]); Assert.AreEqual(val0, valTmp); array1.Get(1, @valTmp[0]); Assert.AreEqual(val1, valTmp); array1.Get(2, @valTmp[0]); Assert.AreEqual(val2, valTmp); array1.Swap(1, 1); Assert.AreEqual(3, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.Get(0, @valTmp[0]); Assert.AreEqual(val0, valTmp); array1.Get(1, @valTmp[0]); Assert.AreEqual(val1, valTmp); array1.Get(2, @valTmp[0]); Assert.AreEqual(val2, valTmp); array1.Swap(2, 2); Assert.AreEqual(3, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.Get(0, @valTmp[0]); Assert.AreEqual(val0, valTmp); array1.Get(1, @valTmp[0]); Assert.AreEqual(val1, valTmp); array1.Get(2, @valTmp[0]); Assert.AreEqual(val2, valTmp); array1.Swap(1, 0); Assert.AreEqual(3, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.Get(0, @valTmp[0]); Assert.AreEqual(val1, valTmp); array1.Get(1, @valTmp[0]); Assert.AreEqual(val0, valTmp); array1.Get(2, @valTmp[0]); Assert.AreEqual(val2, valTmp); array1.Swap(0, 2); Assert.AreEqual(3, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.Get(0, @valTmp[0]); Assert.AreEqual(val2, valTmp); array1.Get(1, @valTmp[0]); Assert.AreEqual(val0, valTmp); array1.Get(2, @valTmp[0]); Assert.AreEqual(val1, valTmp); array1.Swap(2, 1); Assert.AreEqual(3, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.Get(0, @valTmp[0]); Assert.AreEqual(val2, valTmp); array1.Get(1, @valTmp[0]); Assert.AreEqual(val1, valTmp); array1.Get(2, @valTmp[0]); Assert.AreEqual(val0, valTmp); Assert.WillRaise(procedure begin array1.Swap(0, 3); end, ERangeError, 'index out of bounds 1'); Assert.WillRaise(procedure begin array1.Swap(1, 4); end, ERangeError, 'index out of bounds 2'); Assert.WillRaise(procedure begin array1.Swap(3, 3); end, ERangeError, 'index out of bounds 3'); Assert.WillRaise(procedure begin array1.Swap(3, 0); end, ERangeError, 'index out of bounds 4'); Assert.WillRaise(procedure begin array1.Swap(4, 0); end, ERangeError, 'index out of bounds 5'); Assert.WillRaise(procedure begin array1.Swap(4, 2); end, ERangeError, 'index out of bounds 6'); Assert.WillRaise(procedure begin array1.Swap(3, 2); end, ERangeError, 'index out of bounds 7'); Assert.WillRaise(procedure begin array1.Swap(10, 10); end, ERangeError, 'index out of bounds 8'); Assert.WillRaise(procedure begin array1.Swap(11, 109); end, ERangeError, 'index out of bounds 9'); end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestDeleteValue1; var I: Integer; v, v2: TArray<Byte>; begin // because we are adding v into both arrays - it should have enough length to be added into array1 and array2 SetLength(v, Math.max(array1.ItemSize, array2.ItemSize)); SetLength(v2, Math.max(array1.ItemSize, array2.ItemSize)); for I := 0 to 9 do begin PInteger(@v[0])^ := -(i + 1); // just to occupy all integer bytes array1.Add(@v[0]); array2.Add(@v[0]); end; Assert.AreEqual(10, array1.Count); Assert.AreEqual(10, array2.Count); Assert.AreEqual(12, array1.Capacity); Assert.AreEqual(12, array2.Capacity); array1.Delete(0); array2.Delete(0); Assert.AreEqual(9, array1.Count); Assert.AreEqual(9, array2.Count); Assert.AreEqual(12, array1.Capacity); Assert.AreEqual(12, array2.Capacity); for I := 0 to 8 do begin array1.Get(i, @v[0]); PInteger(@v2[0])^ := -(i + 2); Assert.AreEqual(v2, v); array2.Get(i, @v[0]); PInteger(@v2[0])^ := -(i + 2); Assert.AreEqual(v2, v); end; Assert.WillRaise(procedure begin array1.Delete(array1.Count); end, ERangeError, 'DeleteValue at Count'); // try to delete out of range element Assert.AreEqual(9, array1.Count); array1.Delete(array1.Count - 1); //try to delete last element in the array array2.Delete(array2.Count - 1); //try to delete last element in the array Assert.AreEqual(8, array1.Count); Assert.AreEqual(8, array2.Count); Assert.AreEqual(12, array1.Capacity); Assert.AreEqual(12, array2.Capacity); for I := 0 to 7 do begin array1.Get(i, @v[0]); PInteger(@v2[0])^ := -(i + 2); // just to occupy all integer bytes Assert.AreEqual(v, v2); array2.Get(i, @v[0]); PInteger(@v2[0])^ := -(i + 2); Assert.AreEqual(v2, v); end; end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestDeleteValue2; var I: Integer; v, vTmp: TArray<Byte>; begin for I := 1 to 5 do begin Insert(i + 1, v, 0); array1.Add(@v[0]); end; Assert.AreEqual(5, array1.Count); Assert.AreEqual(8, array1.Capacity); array1.Delete(0); Assert.AreEqual(4, array1.Count); Assert.AreEqual(8, array1.Capacity); array1.Delete(0); Assert.AreEqual(3, array1.Count); Assert.AreEqual(8, array1.Capacity); array1.Delete(0); Assert.AreEqual(2, array1.Count); Assert.AreEqual(8, array1.Capacity); array1.Delete(0); Assert.AreEqual(1, array1.Count); Assert.AreEqual(8, array1.Capacity); array1.Delete(0); Assert.AreEqual(0, array1.Count); Assert.AreEqual(8, array1.Capacity); Assert.WillRaise(procedure begin array1.Delete(0); end, ERangeError, 'DeleteValue at 0'); // try to delete out of range element Assert.WillRaise(procedure begin array1.Delete(0); end, ERangeError, 'DeleteValue at 0'); // try to delete out of range element Assert.WillRaise(procedure begin array1.Delete(1); end, ERangeError, 'DeleteValue at 1'); // try to delete out of range element SetLength(v, array1.ItemSize); SetLength(vTmp, array1.ItemSize); for I := 1 to 5 do begin PInteger(@v[0])^ := I; array1.Add(@v[0]); end; Assert.AreEqual(5, array1.Count); Assert.AreEqual(8, array1.Capacity); array1.Delete(1); array1.Get(0, @vTmp[0]); PInteger(@v[0])^ := 1; Assert.AreEqual(v, vTmp); array1.Get(1, @vTmp[0]); PInteger(@v[0])^ := 3; Assert.AreEqual(v, vTmp); Assert.AreEqual(4, array1.Count); Assert.AreEqual(8, array1.Capacity); array1.Delete(1); array1.Get(0, @vTmp[0]); PInteger(@v[0])^ := 1; Assert.AreEqual(v, vTmp); array1.Get(1, @vTmp[0]); PInteger(@v[0])^ := 4; Assert.AreEqual(v, vTmp); Assert.AreEqual(3, array1.Count); Assert.AreEqual(8, array1.Capacity); array1.Delete(1); array1.Get(0, @vTmp[0]); PInteger(@v[0])^ := 1; Assert.AreEqual(v, vTmp); array1.Get(1, @vTmp[0]); PInteger(@v[0])^ := 5; Assert.AreEqual(v, vTmp); Assert.AreEqual(2, array1.Count); Assert.AreEqual(8, array1.Capacity); array1.Delete(1); array1.Get(0, @vTmp[0]); PInteger(@v[0])^ := 1; Assert.AreEqual(v, vTmp); Assert.AreEqual(1, array1.Count); Assert.AreEqual(8, array1.Capacity); Assert.WillRaise(procedure begin array1.Delete(1); end, ERangeError, 'DeleteValue at 0'); // try to delete out of range element Assert.AreEqual(1, array1.Count); Assert.AreEqual(8, array1.Capacity); array1.Clear; for I := 1 to 5 do begin PInteger(@v[0])^ := I; array1.Add(@v[0]); end; Assert.AreEqual(5, array1.Count); Assert.AreEqual(8, array1.Capacity); array1.Delete(array1.Count - 1); Assert.AreEqual(4, array1.Count); Assert.AreEqual(8, array1.Capacity); array1.Delete(array1.Count - 1); Assert.AreEqual(3, array1.Count); Assert.AreEqual(8, array1.Capacity); array1.Delete(array1.Count - 1); Assert.AreEqual(2, array1.Count); Assert.AreEqual(8, array1.Capacity); array1.Delete(array1.Count - 1); Assert.AreEqual(1, array1.Count); Assert.AreEqual(8, array1.Capacity); array1.Delete(array1.Count - 1); Assert.AreEqual(0, array1.Count); Assert.AreEqual(8, array1.Capacity); Assert.WillRaise(procedure begin array1.Delete(array1.Count); end, ERangeError, 'DeleteValue at 0'); // try to delete out of range element Assert.AreEqual(0, array1.Count); Assert.AreEqual(8, array1.Capacity); end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestIndexOf1; var v, vv, vvv: TArray<Byte>; begin SetLength(v, array1.ItemSize); SetLength(vv, array1.ItemSize); SetLength(vvv, array1.ItemSize); PInteger(@v[0])^ := 777; PInteger(@vv[0])^ := 4; PInteger(@vvv[0])^ := 0; Assert.AreEqual(-1, array1.IndexOf(nil)); Assert.AreEqual(-1, array1.IndexOf(@v[0])); Assert.AreEqual(-1, array1.IndexOfFrom(nil, 0)); Assert.AreEqual(-1, array1.IndexOfFrom(nil, 1)); Assert.AreEqual(-1, array1.IndexOfFrom(nil, 2)); Assert.AreEqual(-1, array1.IndexOfFrom(nil, 1000)); Assert.AreEqual(-1, array1.IndexOfFrom(@v[0], 0)); Assert.AreEqual(-1, array1.IndexOfFrom(@v[0], 1)); Assert.AreEqual(-1, array1.IndexOfFrom(@v[0], 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@v[0], 1000)); Assert.AreEqual(-1, array1.IndexOfFrom(@vv[0], 0)); Assert.AreEqual(-1, array1.IndexOfFrom(@vv[0], 1)); Assert.AreEqual(-1, array1.IndexOfFrom(@vv[0], 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@vv[0], 1000)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv[0], 0)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv[0], 1)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv[0], 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv[0], 1000)); end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestIndexOf2(const AValue1, AValue2, AValue3, AValue4: Integer); var v, vv, vvv, vcmp: TArray<Byte>; Ind: Cardinal; bvvv : Boolean absolute vvv; begin Assert.AreNotEqual(AValue1, AValue2, 'AValue1 and AValue2 must not be equal in TestIndexOf2()!'); SetLength(v, array1.ItemSize); SetLength(vv, array1.ItemSize); SetLength(vvv, array1.ItemSize); SetLength(vcmp, array1.ItemSize); PInteger(@v[0])^ := AValue1; PInteger(@vv[0])^ := AValue2; PInteger(@vvv[0])^ := AValue3; Ind := array1.Add(@v[0]); Assert.AreEqual(0, Ind); array1.Get(Ind, @vcmp[0]); Assert.AreEqual(v, vcmp); Assert.AreEqual(array1.IndexOf(@vcmp[0]), array1.IndexOf(@v[0])); Ind := array1.Add(@vv[0]); Assert.AreEqual(1, Ind); array1.Get(Ind, @vcmp[0]); Assert.AreEqual(vv, vcmp); Assert.AreEqual(array1.IndexOf(@vcmp[0]), array1.IndexOf(@vv[0])); Assert.AreEqual(0, array1.IndexOfFrom(@v[0], 0)); Assert.AreEqual(-1, array1.IndexOfFrom(@v[0], 1)); Assert.AreEqual(-1, array1.IndexOfFrom(@v[0], 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@v[0], 333)); Assert.AreEqual(-1, array1.IndexOfFrom(nil, 0)); Assert.AreEqual(-1, array1.IndexOfFrom(nil, 1)); Assert.AreEqual(-1, array1.IndexOfFrom(nil, 2)); Assert.AreEqual(-1, array1.IndexOfFrom(nil, 333)); Assert.AreEqual(1, array1.IndexOfFrom(@vv[0], 0)); Assert.AreEqual(1, array1.IndexOfFrom(@vv[0], 1)); Assert.AreEqual(-1, array1.IndexOfFrom(@vv[0], 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@vv[0], 333)); Assert.AreEqual(-1, array1.IndexOf(@vvv[0])); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv[0], 0)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv[0], 1)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv[0], 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv[0], 333)); end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestInsert1; var I: Integer; val, val2: TArray<Byte>; begin SetLength(val, Math.Max(array1.ItemSize, array2.ItemSize)); SetLength(val2, Math.Max(array1.ItemSize, array2.ItemSize)); for I := 0 to 99 do begin val[0] := i + 100; array1.Insert(0, @val[0]); array2.Insert(0, @val[0]); if array1.Count < 4 then Assert.AreEqual(4, array1.Capacity); if (array1.Count >= 4) AND (array1.Count < 8) then Assert.AreEqual(8, array1.Capacity); if (array1.Count >= 8) AND (array1.Count < 12) then Assert.AreEqual(12, array1.Capacity); if (array1.Count >= 12) AND (array1.Count < 28) then Assert.AreEqual(28, array1.Capacity); if (array1.Count >= 28) AND (array1.Count < 44) then Assert.AreEqual(44, array1.Capacity); if (array1.Count >= 44) AND (array1.Count < 60) then Assert.AreEqual(60, array1.Capacity); if (array1.Count >= 60) AND (array1.Count < 76) then Assert.AreEqual(76, array1.Capacity); if (array1.Count >= 76) AND (array1.Count < 95) then Assert.AreEqual(95, array1.Capacity); if (array1.Count >= 95) then Assert.AreEqual(118, array1.Capacity); end; Assert.AreEqual(118, array1.Capacity); Assert.AreEqual(118, array2.Capacity); Assert.AreEqual(100, array1.Count); Assert.AreEqual(100, array2.Count); for I := 0 to 99 do begin array1.Get(i, @val[0]); val2[0] := 200 - I - 1; Assert.AreEqual(val2, val); end end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestInsert2; var //I: Integer; v1, v2,v3, vv: TArray<Byte>; begin SetLength(v1, array1.ItemSize); SetLength(v2, array1.ItemSize); SetLength(v3, array1.ItemSize); SetLength(vv, array1.ItemSize); PInteger(@v1[0])^ := 111; PInteger(@v2[0])^ := 222; PInteger(@v3[0])^ := 333; array1.Add(@v1[0]); Assert.AreEqual(1, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.Add(@v3[0]); Assert.AreEqual(2, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.Insert(1, @v2[0]); Assert.AreEqual(3, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.Get(0, @v1[0]); PInteger(@vv[0])^ := 111; Assert.AreEqual(vv, v1); array1.Get(1, @v1[0]); PInteger(@vv[0])^ := 222; Assert.AreEqual(vv, v1); array1.Get(2, @v1[0]); PInteger(@vv[0])^ := 333; Assert.AreEqual(vv, v1); array1.Clear; PInteger(@v1[0])^ := 555; array1.Insert(0, @v1[0]); Assert.AreEqual(1, array1.Count); Assert.AreEqual(4, array1.Capacity); PInteger(@v1[0])^ := 666; array1.Insert(array1.Count, @v1[0]); Assert.AreEqual(2, array1.Count); Assert.AreEqual(4, array1.Capacity); PInteger(@v1[0])^ := 777; Assert.WillRaise(procedure begin array1.Insert(3, @v1[0]); end, ERangeError, 'Insert at 3'); Assert.WillRaise(procedure begin array1.Insert(33, @v1[0]); end, ERangeError, 'Insert at 3'); Assert.AreEqual(2, array1.Count); Assert.AreEqual(4, array1.Capacity); end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestQuickFind(AValue1, AValue2, AValue3: string); var token: string; I, Cnt: Integer; findVal, valTmp: TArray<Byte>; begin SetLength(valTmp, array1.ItemSize); SetLength(findVal, array1.ItemSize); Cnt := HGetTokenCount(AValue1, ';', False); for I := 1 to Cnt do begin token := HGetToken(AValue1, ';', False, i - 1); PInteger(@valTmp[0])^ := StrToInt(Trim(token)); array1.Add(@valTmp[0]); end; array1.QuickSort(Compare1); VerifySorting(array1); PInteger(@findVal[0])^ := StrToInt(Trim(AValue2)); Assert.AreEqual(StrToInt(Trim(AValue3)), array1.QuickFind(FindProc, @findVal)); end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestQuickSort1; var v, v2: TArray<Byte>; begin Assert.AreEqual(0, array1.Count); array1.QuickSort(nil); // array is empty so QuickSort will NOT generate an exception that CompareProc is not set. SetLength(v, array1.ItemSize); SetLength(v2, array1.ItemSize); v[0] := 9; array1.Add(@v[0]); array1.QuickSort(nil); // array contains one element so QuickSort will NOT generate an exception that CompareProc is not set. array1.Add(@v[0]); try array1.QuickSort(nil); // here will be exception because array is NOT empty Assert.Fail('We should not be here!'); except on E:Exception do Assert.AreEqual('Cannot sort without CompareProc!', e.Message) end; array1.Clear; array1.QuickSort(Compare1); Assert.AreEqual(0, array1.Count); v[0] := 4; array1.Add(@v[0]); v[0] := 3; array1.Add(@v[0]); v[0] := 5; array1.Add(@v[0]); v[0] := 7; array1.Add(@v[0]); array1.QuickSort(Compare1); array1.Get(0, @v[0]); v2[0] := 3; Assert.AreEqual(v2, v); array1.Get(1, @v[0]); v2[0] := 4; Assert.AreEqual(v2, v); array1.Get(2, @v[0]); v2[0] := 5; Assert.AreEqual(v2, v); array1.Get(3, @v[0]); v2[0] := 7; Assert.AreEqual(v2, v); array1.Clear; v[0] := 4; array1.Add(@v[0]); v[0] := 3; array1.Add(@v[0]); v[0] := 7; array1.Add(@v[0]); v[0] := 6; array1.Add(@v[0]); array1.QuickSort(Compare1); array1.Get(0, @v[0]); v2[0] := 3; Assert.AreEqual(v2, v); array1.Get(1, @v[0]); v2[0] := 4; Assert.AreEqual(v2, v); array1.Get(2, @v[0]); v2[0] := 6; Assert.AreEqual(v2, v); array1.Get(3, @v[0]); v2[0] := 7; Assert.AreEqual(v2, v); end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestQuickSort2(AValue1, AValue2: string); var Cnt: Integer; I: Integer; token: string; v, vv: TArray<Byte>; //cmp: IComparer<TTestArr>; begin //cmp := TComparer<TTestArr>.Default; SetLength(v, array1.ItemSize); SetLength(vv, array1.ItemSize); Cnt := HGetTokenCount(AValue1, ';', False); for I := 1 to Cnt do begin token := HGetToken(AValue1, ';', False, i - 1); PInteger(@v[0])^ := StrToInt(Trim(token)); array1.Add(@v[0]); end; array1.QuickSort(Compare1); VerifySorting(array1); Cnt := HGetTokenCount(AValue2, ';', False); for I := 1 to Cnt do begin token := HGetToken(AValue2, ';', False, i - 1); PInteger(@v[0])^ := StrToInt(Trim(token)); array1.Get(I - 1, @vv[0]); Assert.AreEqual(v, vv); end; Assert.Pass('TestQuickSort2: success.'); end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestSort1; var v, v3, v4, v5, v7: TArray<Byte>; begin Assert.AreEqual(0, array1.Count); array1.SelectionSort(nil); // no exception if CompareProc=nil and array contains <2 elements SetLength(v, array1.ItemSize); SetLength(v3, array1.ItemSize); SetLength(v4, array1.ItemSize); SetLength(v5, array1.ItemSize); SetLength(v7, array1.ItemSize); v5[0] := 5; array1.Add(@v5[0]); Assert.AreEqual(1, array1.Count); array1.SelectionSort(nil); // no exception if CompareProc=nil and array contains <2 elements array1.Clear; Assert.AreEqual(0, array1.Count); array1.SelectionSort(Compare1); Assert.AreEqual(0, array1.Count); v4[0] := 5; array1.Add(@v4[0]); v4[0] := 4; array1.Add(@v4[0]); Assert.AreEqual(2, array1.Count); array1.SelectionSort(Compare1); array1.Get(0, @v[0]); Assert.AreEqual(v4, v); array1.Get(1, @v[0]); Assert.AreEqual(v5, v); array1.Clear; v3[0] := 3; v4[0] := 4; v5[0] := 5; v7[0] := 7; array1.Add(@v4[0]); array1.Add(@v3[0]); array1.Add(@v7[0]); array1.Add(@v5[0]); try array1.SelectionSort(nil); except on E:Exception do Assert.AreEqual('Cannot sort without CompareProc!', E.Message); end; array1.SelectionSort(Compare1); array1.Get(0, @v[0]); Assert.AreEqual(v3, v); array1.Get(1, @v[0]); Assert.AreEqual(v4, v); array1.Get(2, @v[0]); Assert.AreEqual(v5, v); array1.Get(3, @v[0]); Assert.AreEqual(v7, v); array1.Clear; array1.Add(@v7[0]); array1.Add(@v3[0]); array1.Add(@v5[0]); array1.Add(@v4[0]); array1.SelectionSort(Compare1); array1.Get(0, @v[0]); Assert.AreEqual(v3, v); array1.Get(1, @v[0]); Assert.AreEqual(v4, v); array1.Get(2, @v[0]); Assert.AreEqual(v5, v); array1.Get(3, @v[0]); Assert.AreEqual(v7, v); array1.Clear; array1.Add(@v7[0]); array1.Add(@v5[0]); array1.Add(@v4[0]); array1.Add(@v3[0]); array1.SelectionSort(Compare1); array1.Get(0, @v[0]); Assert.AreEqual(v3, v); array1.Get(1, @v[0]); Assert.AreEqual(v4, v); array1.Get(2, @v[0]); Assert.AreEqual(v5, v); array1.Get(3, @v[0]); Assert.AreEqual(v7, v); end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestSort11; var v, v3, v4, v5, v7: TArray<Byte>; begin Assert.AreEqual(0, array1.Count); array1.SelectionSort(nil); // no exception if CompareProc=nil and array contains <2 elements SetLength(v, array1.ItemSize); SetLength(v3, array1.ItemSize); SetLength(v4, array1.ItemSize); SetLength(v5, array1.ItemSize); SetLength(v7, array1.ItemSize); PInteger(@v5[0])^ := 555_555; array1.Add(@v5[0]); Assert.AreEqual(1, array1.Count); array1.SelectionSort(nil); // no exception if CompareProc=nil and array contains <2 elements array1.Clear; Assert.AreEqual(0, array1.Count); array1.SelectionSort(Compare1); Assert.AreEqual(0, array1.Count); PInteger(@v5[0])^ := 555_555; array1.Add(@v5[0]); Assert.AreEqual(1, array1.Count); array1.SelectionSort(Compare1); array1.Clear; PInteger(@v3[0])^ := 333_333; PInteger(@v4[0])^ := 444_444; PInteger(@v5[0])^ := 555_555; PInteger(@v7[0])^ := 777_777; array1.Add(@v4[0]); array1.Add(@v3[0]); array1.Add(@v7[0]); array1.Add(@v5[0]); try array1.SelectionSort(nil); except on E:Exception do Assert.AreEqual('Cannot sort without CompareProc!', E.Message); end; array1.Clear; array1.Add(@v4[0]); array1.Add(@v3[0]); array1.Add(@v7[0]); array1.Add(@v5[0]); array1.SelectionSort(Compare1); array1.Get(0, @v[0]); Assert.AreEqual(v3, v); array1.Get(1, @v[0]); Assert.AreEqual(v4, v); array1.Get(2, @v[0]); Assert.AreEqual(v5, v); array1.Get(3, @v[0]); Assert.AreEqual(v7, v); end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestSort2(AValue1, AValue2: string); var token: string; val, valTmp: TArray<Byte>; I, cnt: Integer; //cmp: IComparer<TArray<Byte>>; begin //cmp := TComparer<TArray<Byte>>.Default; SetLength(valTmp, array1.ItemSize); SetLength(val, array1.ItemSize); cnt := HGetTokenCount(AValue1, ';', False); for I := 1 to cnt do begin token := HGetToken(AValue1, ';', False, i - 1); PInteger(@valTmp[0])^ := StrToInt(Trim(token)); array1.Add(@valTmp[0]); end; array1.SelectionSort(Compare1); VerifySorting(array1); cnt := HGetTokenCount(AValue2, ';', False); for I := 1 to cnt do begin token := HGetToken(AValue2, ';', False, i - 1); PInteger(@valTmp[0])^ := StrToInt(Trim(token)); array1.Get(I - 1, @val[0]); Assert.AreEqual(val, valTmp); end; // if Avalue1 and Avalue2 contain only one value then no Assert.isTrue called in for loop above. // and DUnitX generates a warning "No assertion were made duringhe test" // to eliminate such warning Assert.Pass is added below Assert.Pass('TestSort2: success.'); end; procedure TDynamicArraysTHArrayTest<TTestArr>.VerifySorting(arr: TTestArr); var i: Cardinal; v, vv: TArray<Byte>; cmp: IComparer<TArray<Byte>>; begin cmp := TComparer<TArray<Byte>>.Default; SetLength(v, arr.ItemSize); SetLength(vv, arr.ItemSize); for i := 1 to arr.Count - 1 do begin arr.Get(i - 1, @v[0]); arr.Get(i, @vv[0]); Assert.IsTrue(cmp.Compare(v, vv) <= 0, '*** Array is NOT sorted ***'); end; //Assert.Pass('VerifySorting: Array is properly sorted.'); end; { procedure TDynamicArraysTHArrayTest<TTestArr>.TestQuickSortPerformance; var i: Integer; r: TArray<Byte>; begin array1.SetCapacity(ARRAYSIZE_FOR_SORTING); SetLength(r, array1.ItemSize); for i := 0 to ARRAYSIZE_FOR_SORTING - 1 do begin Pinteger(@r[0])^ := random(10_000); array1.Add(@r[0]); end; var start := GetTickCount; array1.QuickSort(Compare1); TDUnitX.CurrentRunner.Log(Format('QuickSort(%d) = %s', [ARRAYSIZE_FOR_SORTING, MillisecToStr(GetTickCount - start)])); VerifySorting(array1); end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestBubbleSortPerformance; var i: Integer; r: TArray<Byte>; begin array1.SetCapacity(ARRAYSIZE_FOR_SORTING); SetLength(r, array1.ItemSize); for i := 0 to ARRAYSIZE_FOR_SORTING - 1 do begin PInteger(@r[0])^ := random(10_000); array1.Add(@r[0]); end; var start := GetTickCount; array1.BubbleSort(Compare1); TDUnitX.CurrentRunner.Log(Format('BubbleSort(%d) = %s', [ARRAYSIZE_FOR_SORTING, MillisecToStr(GetTickCount - start)])); VerifySorting(array1); end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestSelectionSortPerformance; var i: Integer; r: TArray<Byte>; begin array1.SetCapacity(ARRAYSIZE_FOR_SORTING); SetLength(r, array1.ItemSize); for i := 0 to ARRAYSIZE_FOR_SORTING - 1 do begin PInteger(@r[0])^ := random(10_000); array1.Add(@r[0]); end; var start := GetTickCount; array1.SelectionSort(Compare1); TDUnitX.CurrentRunner.Log(Format('SelectionSort(%d) = %s', [ARRAYSIZE_FOR_SORTING, MillisecToStr(GetTickCount - start)])); VerifySorting(array1); end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestShakerSortPerformance; var i: Integer; r: TArray<Byte>; begin array1.SetCapacity(ARRAYSIZE_FOR_SORTING); SetLength(r, array1.ItemSize); for i := 0 to ARRAYSIZE_FOR_SORTING - 1 do begin PInteger(@r[0])^ := random(10_000); array1.Add(@r[0]); end; var start := GetTickCount; array1.ShakerSort(Compare1); TDUnitX.CurrentRunner.Log(Format('ShakerSort(%d) = %s', [ARRAYSIZE_FOR_SORTING, MillisecToStr(GetTickCount - start)])); VerifySorting(array1); end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestInsertionSortPerformance; var i: Integer; r: TArray<Byte>; begin array1.SetCapacity(ARRAYSIZE_FOR_SORTING); SetLength(r, array1.ItemSize); for i := 0 to ARRAYSIZE_FOR_SORTING - 1 do begin PInteger(@r[0])^ := random(10_000); array1.Add(@r[0]); end; var start := GetTickCount; array1.InsertSort(Compare1); TDUnitX.CurrentRunner.Log(Format('InsertionSort(%d) = %s', [ARRAYSIZE_FOR_SORTING, MillisecToStr(GetTickCount - start)])); VerifySorting(array1); end; } procedure TDynamicArraysTHArrayTest<TTestArr>.CopyArray(arr1, arr2: TTestArr); var i: Cardinal; v: TArray<Byte>; begin Assert.AreEqual(arr1.ItemSize, arr2.ItemSize); arr2.Clear; arr2.SetCapacity(arr1.Capacity); SetLength(v, arr1.ItemSize); for i := 0 to arr1.Count - 1 do begin arr1.Get(i, @v[0]); arr2.Add(@v[0]); end; end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestAllSortAlgsPerformance; var i: Integer; r: TArray<Byte>; arr2: THArray; begin SetLength(r, array1.ItemSize); array1.SetCapacity(ARRAYSIZE_FOR_SORTING); arr2 := THArray.Create; arr2.ItemSize := array1.ItemSize; // then same initial array for all algs for i := 0 to ARRAYSIZE_FOR_SORTING - 1 do begin PInteger(@r[0])^ := random(32_767); array1.Add(@r[0]); end; // we will be sorting array2 CopyArray(array1, arr2); var start := GetTickCount; arr2.BubbleSort(Compare1); TDUnitX.CurrentRunner.Log(Format('BubbleSort(%d) = %s', [ARRAYSIZE_FOR_SORTING, MillisecToStr(GetTickCount - start)])); VerifySorting(arr2); CopyArray(array1, arr2); start := GetTickCount; arr2.SelectionSort(Compare1); TDUnitX.CurrentRunner.Log(Format('SelectionSort(%d) = %s', [ARRAYSIZE_FOR_SORTING, MillisecToStr(GetTickCount - start)])); VerifySorting(arr2); CopyArray(array1, arr2); start := GetTickCount; arr2.ShakerSort(Compare1); TDUnitX.CurrentRunner.Log(Format('ShakerSort(%d) = %s', [ARRAYSIZE_FOR_SORTING, MillisecToStr(GetTickCount - start)])); VerifySorting(arr2); {CopyArray(array1, arr2); start := GetTickCount; arr2.InsertionSort(Compare1); TDUnitX.CurrentRunner.Log(Format('InsertionSort(%d) = %s', [ARRAYSIZE_FOR_SORTING, MillisecToStr(GetTickCount - start)])); VerifySorting(arr2); } CopyArray(array1, arr2); start := GetTickCount; arr2.QuickSort(Compare1); TDUnitX.CurrentRunner.Log(Format('QuiuckSort(%d) = %s', [ARRAYSIZE_FOR_SORTING, MillisecToStr(GetTickCount - start)])); VerifySorting(arr2); arr2.Free; end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestCapacity1; begin Assert.AreEqual(0, array1.Capacity); array1.SetCapacity(1); Assert.AreEqual(1, array1.Capacity); Assert.AreEqual(0, array1.Count); array1.SetCapacity(0); Assert.AreEqual(0, array1.Capacity); array1.SetCapacity(2); Assert.AreEqual(2, array1.Capacity); Assert.AreEqual(0, array1.Count); array1.SetCapacity(3); Assert.AreEqual(3, array1.Capacity); Assert.AreEqual(0, array1.Count); array1.SetCapacity(100_000_000); Assert.AreEqual(100_000_000, array1.Capacity); Assert.AreEqual(0, array1.Count); array1.SetCapacity(0); Assert.AreEqual(0, array1.Capacity); Assert.AreEqual(0, array1.Count); array1.SetCapacity(100); Assert.AreEqual(100, array1.Capacity); Assert.AreEqual(0, array1.Count); array1.Zero; Assert.AreEqual(100, array1.Capacity); array1.Clear(); Assert.AreEqual(100, array1.Capacity); array1.Hold; Assert.AreEqual(0, array1.Capacity); Assert.AreEqual(0, array1.Count); array1.SetCapacity(200); array1.ClearMem(); Assert.AreEqual(0, array1.Capacity); end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestCapacity2; var i: Integer; v: TArray<Byte>; begin SetLength(v, array1.ItemSize); for i := 0 to 499 do begin PInteger(@v[0])^ := i; array1.Add(@v[0]); end; Assert.AreEqual(556, array1.Capacity); array1.Hold(); Assert.AreEqual(500, array1.Capacity); array1.SetCapacity(600); Assert.AreEqual(600, array1.Capacity); Assert.AreEqual(500, array1.Count); array1.SetCapacity(400); Assert.AreEqual(400, array1.Capacity); Assert.AreEqual(400, array1.Count); array1.SetCapacity(0); Assert.AreEqual(0, array1.Capacity); Assert.AreEqual(0, array1.Count); end; function TDynamicArraysTHArrayTest<TTestArr>.Compare1(arr: THArray; i, j: Cardinal): Integer; var v1, v2: TArray<Byte>; begin if NOT Assigned(FMyComparer) then FMyComparer := TComparer<TArray<Byte>>.Default; // should be called only once SetLength(v1, arr.ItemSize); SetLength(v2, arr.ItemSize); arr.Get(i, @v1[0]); arr.Get(j, @v2[0]); Result := FMyComparer.Compare(v1, v2); end; function TDynamicArraysTHArrayTest<TTestArr>.FindProc(arr: THArray; i: Cardinal; FindData: Pointer): Integer; //const // cmp: IComparer<TArray<Byte>> = nil; // analogue of static variable which saves its value between function calls type TArrayByte = TArray<Byte>; PArrayByte = ^TArrayByte; var v1, v2: TArray<Byte>; begin if NOT Assigned(FMyComparer) then FMyComparer := TComparer<TArrayByte>.Default; // should be called only once SetLength(v2, arr.ItemSize); v1 := PArrayByte(FindData)^; arr.Get(i, @v2[0]); Result := FMyComparer.Compare(v1, v2); end; function TDynamicArraysTHArrayTest<TTestArr>.Compare2(Item1, Item2: TArray<Byte>): Integer; //const // cmp: IComparer<TArray<Byte>> = nil; // analogue of static variable which saves its value between function calls begin if NOT Assigned(FMyComparer) then FMyComparer := TComparer<TArray<Byte>>.Default; // should be called only once Result := FMyComparer.Compare(Item1, Item2); end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestAddClearAdd1; var I: Integer; v, v2: TArray<Byte>; begin SetLength(v, Math.Max(array1.ItemSize, array2.ItemSize)); SetLength(v2, Math.Max(array1.ItemSize, array2.ItemSize)); for I := 5 to 9 do begin v[0] := I; array1.Insert(array1.Count, @v[0]); array2.Insert(array2.Count, @v[0]); end; Assert.AreEqual(8, array1.Capacity); Assert.AreEqual(8, array2.Capacity); Assert.AreEqual(5, array1.Count); Assert.AreEqual(5, array2.Count); array1.ClearMem; array2.ClearMem; Assert.AreEqual(0, array1.Count); Assert.AreEqual(0, array2.Count); Assert.AreEqual(0, array1.Capacity); Assert.AreEqual(0, array2.Capacity); for I := 15 to 19 do begin v[0] := I; array1.Insert(array1.Count, @v[0]); array2.Insert(array2.Count, @v[0]); end; Assert.AreEqual(8, array1.Capacity); Assert.AreEqual(8, array2.Capacity); Assert.AreEqual(5, array1.Count); Assert.AreEqual(5, array2.Count); for I := 0 to 4 do begin array2.Get(I, @v[0]); v2[0] := I + 15; Assert.AreEqual(v2, v); end; for I := 0 to 4 do begin array2.Get(I, @v2[0]); array1.Get(I, @v[0]); Assert.AreEqual(v2, v); end; end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestAddClearAdd2; var I: Integer; v, v2: TArray<Byte>; begin SetLength(v, Math.Max(array1.ItemSize, array2.ItemSize)); SetLength(v2, Math.Max(array1.ItemSize, array2.ItemSize)); for I := -9 to -5 do begin PInteger(@v[0])^ := I; array1.Insert(array1.Count, @v[0]); array2.Insert(array2.Count, @v[0]); end; Assert.AreEqual(8, array1.Capacity); Assert.AreEqual(8, array2.Capacity); Assert.AreEqual(5, array1.Count); Assert.AreEqual(5, array2.Count); array1.Clear; array2.Clear; Assert.AreEqual(8, array1.Capacity); Assert.AreEqual(8, array2.Capacity); Assert.AreEqual(0, array1.Count); Assert.AreEqual(0, array2.Count); for I := -19 to -15 do begin PInteger(@v[0])^ := I; array1.Insert(array1.Count, @v[0]); array2.Insert(array2.Count, @v[0]); end; Assert.AreEqual(8, array1.Capacity); Assert.AreEqual(8, array2.Capacity); Assert.AreEqual(5, array1.Count); Assert.AreEqual(5, array2.Count); for I := 0 to 4 do begin array2.Get(I, @v[0]); PInteger(@v2[0])^ := I - 19; Assert.AreEqual(v2, v); end; for I := 0 to 4 do begin array2.Get(I, @v2[0]); array1.Get(I, @v[0]); Assert.AreEqual(v2, v); end; end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestAddMany; var val, valTmp: TArray<Byte>; val1, val2, val3: TArray<Byte>; arr: TArray<Byte>; begin SetLength(val, array1.ItemSize); SetLength(valTmp, array1.ItemSize); SetLength(val1, array1.ItemSize); SetLength(val2, array1.ItemSize); SetLength(val3, array1.ItemSize); PInteger(@val[0])^ := 999; array1.AddMany(@val[0], 0); Assert.AreEqual(0, array1.Count); Assert.AreEqual(0, array1.Capacity); array1.AddMany(nil, 0); Assert.AreEqual(0, array1.Count); Assert.AreEqual(0, array1.Capacity); array1.AddMany(@val[0], 1); Assert.AreEqual(1, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.Get(0, @valTmp[0]); Assert.AreEqual(val, valTmp); array1.Clear; SetLength(arr, 4*array1.ItemSize); PInteger(@arr[0])^ := PInteger(@val[0])^; PInteger(@arr[1*array1.ItemSize])^ := PInteger(@val[0])^; PInteger(@arr[2*array1.ItemSize])^ := PInteger(@val[0])^; PInteger(@arr[3*array1.ItemSize])^ := PInteger(@val[0])^; array1.AddMany(@(arr[0]), 4); Assert.AreEqual(4, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.Get(0, @valTmp[0]); Assert.AreEqual(val, valTmp); array1.Get(1, @valTmp[0]); Assert.AreEqual(val, valTmp); array1.Get(2, @valTmp[0]); Assert.AreEqual(val, valTmp); array1.Get(3, @valTmp[0]); Assert.AreEqual(val, valTMp); array1.Clear; PInteger(@val1[0])^ := 44; PInteger(@val2[0])^ := 105; PInteger(@val3[0])^ := 909; array1.Add(@val1[0]); array1.Add(@val2[0]); array1.Add(@val3[0]); Assert.AreEqual(3, array1.Count); Assert.AreEqual(4, array1.Capacity); SetLength(arr, 5*array1.ItemSize); PInteger(@arr[4*array1.ItemSize])^ := PInteger(@val[0])^; array1.AddMany(@(arr[0]), 5); Assert.AreEqual(8, array1.Count); Assert.AreEqual(8, array1.Capacity); array1.Get(0, @valTmp[0]); Assert.AreEqual(val1, valTmp); array1.Get(1, @valTmp[0]); Assert.AreEqual(val2, valTmp); array1.Get(2, @valTmp[0]); Assert.AreEqual(val3, valTmp); array1.Get(3, @valTmp[0]); Assert.AreEqual(val, valTmp); array1.Get(4, @valTmp[0]); Assert.AreEqual(val, valTmp); array1.Get(5, @valTmp[0]); Assert.AreEqual(val, valTmp); array1.Get(6, @valTmp[0]); Assert.AreEqual(val, valTmp); array1.Get(7, @valTmp[0]); Assert.AreEqual(val, valTmp); array1.Clear; end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestAddFillValues; var i: Integer; val, valTmp: TArray<Byte>; begin SetLength(val, array1.ItemSize); SetLength(valTmp, array1.ItemSize); array1.AddFillValues(0); Assert.AreEqual(0, array1.Count); Assert.AreEqual(0, array1.Capacity); array1.AddFillValues(1); Assert.AreEqual(1, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.Get(0, @valTmp[0]); val[0] := 0; Assert.AreEqual(val, valTmp); array1.AddFillValues(4); Assert.AreEqual(5, array1.Count); Assert.AreEqual(8, array1.Capacity); val[0] := 0; for i := 0 to 4 do begin array1.Get(i, @valTmp[0]); Assert.AreEqual(val, valTmp); end; end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestInsertMany; var val, valTmp: TArray<Byte>; val1, val2, val3: TArray<Byte>; arr: TArray<Byte>; begin SetLength(val, array1.ItemSize); SetLength(val1, array1.ItemSize); SetLength(val2, array1.ItemSize); SetLength(val3, array1.ItemSize); SetLength(valTmp, array1.ItemSize); PInteger(@val[0])^ := 999; array1.InsertMany(0, @val[0], 0); array1.InsertMany(1, @val[0], 0); Assert.AreEqual(0, array1.Count); Assert.AreEqual(0, array1.Capacity); array1.InsertMany(0, @val[0], 1); Assert.AreEqual(1, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.Get(0, @valTmp[0]); Assert.AreEqual(val, valTmp); array1.Clear; Assert.AreEqual(sizeof(Byte), sizeof(arr[0])); SetLength(arr, 4*array1.ItemSize); PInteger(@arr[0])^ := PInteger(@val[0])^; PInteger(@arr[1*array1.ItemSize])^ := PInteger(@val[0])^; PInteger(@arr[2*array1.ItemSize])^ := PInteger(@val[0])^; PInteger(@arr[3*array1.ItemSize])^ := PInteger(@val[0])^; array1.InsertMany(0, @arr[0], 4); Assert.AreEqual(4, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.Get(0, @valTmp[0]); Assert.AreEqual(val, valTmp); array1.Get(1, @valTmp[0]); Assert.AreEqual(val, valTmp); array1.Get(2, @valTmp[0]); Assert.AreEqual(val, valTmp); array1.Get(3, @valTmp[0]); Assert.AreEqual(val, valTmp); array1.Clear; PInteger(@val1[0])^ := 44; PInteger(@val2[0])^ := 105; PInteger(@val3[0])^ := 909; array1.Add(@val1[0]); array1.Add(@val2[0]); array1.Add(@val3[0]); Assert.AreEqual(3, array1.Count); Assert.AreEqual(4, array1.Capacity); SetLength(arr, 5*array1.ItemSize); PInteger(@arr[4*array1.ItemSize])^ := PInteger(@val[0])^; array1.InsertMany(1, @arr[0], 5); Assert.AreEqual(8, array1.Count); Assert.AreEqual(8, array1.Capacity); array1.Get(0, @valTmp[0]); Assert.AreEqual(val1, valTmp); array1.Get(1, @valTmp[0]); Assert.AreEqual(val, valTmp); array1.Get(2, @valTmp[0]); Assert.AreEqual(val, valTmp); array1.Get(3, @valTmp[0]); Assert.AreEqual(val, valTmp); array1.Get(4, @valTmp[0]); Assert.AreEqual(val, valTmp); array1.Get(5, @valTmp[0]); Assert.AreEqual(val, valTmp); array1.Get(6, @valTmp[0]); Assert.AreEqual(val2, valTmp); array1.Get(7, @valTmp[0]); Assert.AreEqual(val3, valTmp); array1.InsertMany(0, @arr[0], 5); Assert.AreEqual(13, array1.Count); Assert.AreEqual(13, array1.Capacity); array1.InsertMany(1, @arr[0], 5); Assert.AreEqual(18, array1.Count); Assert.AreEqual(29, array1.Capacity); array1.InsertMany(array1.Count, @arr[0], 5); Assert.AreEqual(23, array1.Count); Assert.AreEqual(29, array1.Capacity); Assert.WillRaise(procedure begin array1.InsertMany(array1.Count + 1, @arr[0], 5) end, ERangeError, 'insertMany1'); end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestAddTwoDiff(const AValue1, AValue2 : Integer); var v, vv, vvv, vTmp: TArray<Byte>; cmp: IComparer<TArray<Byte>>; begin Assert.AreNotEqual(AValue1, AValue2, 'AValue1 and AValue2 must be not equal in TestAddTwoDiff()!'); SetLength(v, array1.ItemSize); SetLength(vv, array1.ItemSize); SetLength(vvv, array1.ItemSize); SetLength(vTmp, array1.ItemSize); PInteger(@v[0])^ := AValue1; PInteger(@vv[0])^ := AValue2; array1.Add(@v[0]); array1.Add(@vv[0]); array1.Get(0, @vTmp[0]); Assert.AreEqual(v, vTmp); array1.Get(1, @vTmp[0]); Assert.AreEqual(vv, vTmp); array1.Get(0, @vTmp[0]); Assert.AreEqual(v, vTmp); Assert.WillRaise(procedure begin array1.GetAddr(2) end, ERangeError, 'get2'); Assert.WillRaise(procedure begin array1.GetAddr(3) end, ERangeError, 'get3'); Assert.WillRaise(procedure begin array1.GetAddr(11) end, ERangeError, 'get11'); Assert.WillRaise(procedure begin array1.Get(2, nil) end, EAssertionFailed, 'get2'); Assert.WillRaise(procedure begin array1.Get(2, @vTmp[0]) end, ERangeError, 'get3'); Assert.WillRaise(procedure begin array1.Get(11, nil) end, EAssertionFailed, 'get11'); Assert.AreEqual(0, array1.IndexOf(@v[0])); Assert.AreEqual(1, array1.IndexOf(@vv[0])); Assert.AreEqual(0, array1.IndexOfFrom(@v[0], 0)); Assert.AreEqual(-1, array1.IndexOfFrom(@v[0], 1)); Assert.AreEqual(-1, array1.IndexOfFrom(@v[0], 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@vv[0], 3)); Assert.AreEqual(-1, array1.IndexOfFrom(@v[0], 555)); Assert.AreEqual( 1, array1.IndexOfFrom(@vv[0], 0)); Assert.AreEqual( 1, array1.IndexOfFrom(@vv[0], 1)); Assert.AreEqual(-1, array1.IndexOfFrom(@vv[0], 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@vv[0], 3)); Assert.AreEqual(-1, array1.IndexOfFrom(@vv[0], 555)); cmp := TComparer<TArray<Byte>>.Default; if (AValue1 <> 0) AND (AValue2 <> 0) then begin PInteger(@vvv[0])^ := AValue1 + AValue2; if (cmp.Compare(vvv, v) <> 0) AND (cmp.Compare(vvv, vv) <> 0) then Assert.AreEqual(-1, array1.IndexOf(@vvv[0])); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv[0], 0)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv[0], 1)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv[0], 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv[0], 555)); PInteger(@vvv[0])^ := AValue1 - AValue2; if (cmp.Compare(vvv, v) <> 0) AND (cmp.Compare(vvv, vv) <> 0) then Assert.AreEqual(-1, array1.IndexOf(@vvv[0])); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv[0], 0)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv[0], 1)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv[0], 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv[0], 555)); end; end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestAddTwoEqual(const AValue1, AValue2: Integer); var v,vv,vvv, vTmp: TArray<Byte>; s: string absolute v; ss: string absolute vv; cmp: IComparer<TArray<Byte>>; begin Assert.AreEqual(AValue1, AValue2, 'AValue1 and AValue2 must be equal in TestAddTwoEqual()!'); SetLength(v, array1.ItemSize); SetLength(vv, array1.ItemSize); SetLength(vvv, array1.ItemSize); SetLength(vTmp, array1.ItemSize); PInteger(@v[0])^ := AValue1; PInteger(@vv[0])^ := AValue2; array1.Add(@v[0]); array1.Add(@vv[0]); Assert.AreEqual(v, vv); array1.Get(1, @vTmp[0]); Assert.AreEqual(v, vTmp); array1.Get(0, @vTmp[0]); Assert.AreEqual(vv, vTmp); Assert.AreEqual(0, array1.IndexOf(@v[0])); Assert.AreEqual(0, array1.IndexOf(@vv[0])); array1.Get(0, @vTmp[0]); Assert.AreEqual(v, vTmp); array1.Get(1, @vTmp[0]); Assert.AreEqual(vv, vTmp); Assert.WillRaise(procedure begin array1.GetAddr(2) end, ERangeError, 'get2'); Assert.WillRaise(procedure begin array1.GetAddr(3) end, ERangeError, 'get3'); Assert.WillRaise(procedure begin array1.GetAddr(66) end, ERangeError, 'get66'); Assert.WillRaise(procedure begin array1.Get(2, nil) end, EAssertionFailed, 'get2'); Assert.WillRaise(procedure begin array1.Get(2, @vTmp[0]) end, ERangeError, 'get3'); Assert.WillRaise(procedure begin array1.Get(11, nil) end, EAssertionFailed, 'get11'); Assert.AreEqual(-1, array1.IndexOfFrom(nil, 0)); Assert.AreEqual(0, array1.IndexOfFrom(@v[0], 0)); Assert.AreEqual(1, array1.IndexOfFrom(@v[0], 1)); Assert.AreEqual(0, array1.IndexOfFrom(@vv[0], 0)); Assert.AreEqual(1, array1.IndexOfFrom(@vv[0], 1)); Assert.AreEqual(-1, array1.IndexOfFrom(@v[0], 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@v[0], 3)); Assert.AreEqual(-1, array1.IndexOfFrom(@v[0], 555)); Assert.AreEqual(-1, array1.IndexOfFrom(@vv[0], 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@vv[0], 3)); Assert.AreEqual(-1, array1.IndexOfFrom(@vv[0], 555)); Assert.AreEqual(-1, array1.IndexOfFrom(nil, 555)); cmp := TComparer<TArray<Byte>>.Default; if AValue1 <> 0 then begin PInteger(@vvv[0])^ := AValue1 + AValue2; if (cmp.Compare(vvv, v) <> 0) AND (cmp.Compare(vvv, vv) <> 0) then begin Assert.AreEqual(-1, array1.IndexOf(@vvv[0])); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv[0], 0)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv[0], 1)); end; Assert.AreEqual(-1, array1.IndexOfFrom(@vvv[0], 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv[0], 555)); PInteger(@vvv[0])^ := AValue1 - AValue2; if (cmp.Compare(vvv, v) <> 0) AND (cmp.Compare(vvv, vv) <> 0) then begin Assert.AreEqual(-1, array1.IndexOf(@vvv[0])); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv[0], 0)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv[0], 1)); end; Assert.AreEqual(-1, array1.IndexOfFrom(@vvv[0], 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv[0], 555)); end; end; procedure TDynamicArraysTHArrayTest<TTestArr>.TestGrow; var i: Integer; v: TArray<Byte>; begin SetLength(v, array1.ItemSize); Assert.AreEqual(0, array1.Capacity); v[0] := 11; array1.Add(@v[0]); Assert.AreEqual(4, array1.Capacity); v[0] := 22; array1.Add(@v[0]); v[0] := 33; array1.Add(@v[0]); Assert.AreEqual(4, array1.Capacity); v[0] := 44; array1.Add(@v[0]); Assert.AreEqual(8, array1.Capacity); v[0] := 11; array1.Add(@v[0]); v[0] := 55; array1.Add(@v[0]); v[0] := 66; array1.Add(@v[0]); v[0] := 77; array1.Add(@v[0]); Assert.AreEqual(12, array1.Capacity); v[0] := 11; array1.Add(@v[0]); Assert.AreEqual(12, array1.Capacity); Assert.AreEqual(9, array1.Count); for i := 0 to 2 do begin v[0] := i + 11; array1.Add(@v[0]); end; Assert.AreEqual(28, array1.Capacity); for i := 0 to 15 do begin v[0] := i + 11; array1.Add(@v[0]); end; Assert.AreEqual(28, array1.Count); Assert.AreEqual(44, array1.Capacity); for i := 0 to 15 do begin v[0] := i + 11; array1.Add(@v[0]); end; Assert.AreEqual(44, array1.Count); Assert.AreEqual(60, array1.Capacity); for i := 0 to 15 do begin v[0] := i + 11; array1.Add(@v[0]); end; Assert.AreEqual(60, array1.Count); Assert.AreEqual(76, array1.Capacity); for i := 0 to 15 do begin v[0] := i + 11; array1.Add(@v[0]); end; Assert.AreEqual(76, array1.Count); Assert.AreEqual(95, array1.Capacity); for i := 0 to 18 do begin v[0] := i + 11; array1.Add(@v[0]); end; Assert.AreEqual(95, array1.Count); Assert.AreEqual(118, array1.Capacity); array1.Clear(); Assert.AreEqual(0, array1.Count); Assert.AreEqual(118, array1.Capacity); array1.GrowTo(100); Assert.AreEqual(0, array1.Count); Assert.AreEqual(118, array1.Capacity); end; initialization Randomize; // need for testing sorting algs performance TDUnitX.RegisterTestFixture(TDynamicArraysTHArrayTest<THArray>); end.