/
lasersquad
/
DynamicArrays
Обзор
Документация
Войти
/
lasersquad
/
DynamicArrays
Код
Задачи
Вики
Пакеты
0
Релизы
0
Аналитика
Безопасность
master
dynamicarrays/prj/Delphi/DynamicArraysOTests/DynamicArraysBaseTest.pas
2 105 строк
62 KB
lasersquad0
new files
20 май 2026, 22:15
20 май 2026, 22:15
b70be5f
Код
Авторство
О чём код?
unit DynamicArraysBaseTest; interface uses DUnitX.TestFramework, {TestBase,} DynamicArrays; type TDynamicArraysBaseTest<TT: constructor, THArray; InnerT: record> = class //(TTestBase) protected type TTestingArrayType = TT; TSortMethod = procedure(CompareProc: TCompareProc) of object; protected procedure TestSort1(Method: TSortMethod); overload; virtual; procedure TestSort2(Method: TSortMethod; AValue1, AValue2: string); overload; virtual; function FindProc(arr : THArray; i : Cardinal; FindData: Pointer): Integer; function Compare1(arr: THArray; i, j: Cardinal): Integer; function Compare2(Item1, Item2: InnerT): Integer; function IsTTBoolean: Boolean; function IsTTUnsigned: Boolean; procedure VerifySorting(arr: TT); procedure CopyArray(arr1, arr2: TTestingArrayType); protected array1: TTestingArrayType; array2: TTestingArrayType; function GetValueForRandom(a: TT): Integer; protected procedure TestEmpty1; virtual; procedure TestEmpty2; virtual; procedure TestCountOne; virtual; procedure TestUpdate; virtual; procedure TestUpdateMany; virtual; procedure TestZero; virtual; procedure TestSwap; virtual; procedure TestAddFillValues1; virtual; procedure TestAddFillValues2; virtual; procedure TestIndexOF1; virtual; procedure TestIndexOf2(AValue1, AValue2, AValue3, AValue4: Integer); virtual; procedure TestCapacity1; virtual; procedure TestCapacity2; virtual; procedure TestAddTwoDiff(AValue1, AValue2 : Integer); virtual; procedure TestAddTwoEqual(AValue1, AValue2 : Integer); virtual; procedure TestGrow; virtual; procedure TestInsert1; virtual; procedure TestInsert2; virtual; procedure TestDeleteValue1; virtual; procedure TestDeleteValue2; virtual; procedure TestAddClearAdd1; virtual; procedure TestAddClearAdd2; virtual; procedure TestSort1; overload; virtual; procedure TestSort2(AValue1, AValue2: string); overload; virtual; procedure TestAddMany; virtual; procedure TestInsertMany; virtual; procedure TestBubbleSortPerformance; virtual; procedure TestSelectionSortPerformance; virtual; procedure TestQuickSortPerformance; virtual; procedure TestShakerSortPerformance; virtual; procedure TestQuickFind(AValue1, AValue2, AValue3: string); virtual; procedure TestQuickSort1; virtual; procedure TestQuickSort2(AValue1, AValue2: string); virtual; procedure TestHGetToken1; virtual; procedure TestAllSortAlgsPerformance; virtual; end; const ARRAYSIZE_FOR_SORTING = 20_000; implementation uses System.TypInfo, System.Generics.Defaults, SysUtils, Winapi.Windows, DynamicArraysUtils; procedure TDynamicArraysBaseTest<TT, InnerT>.TestEmpty1; begin Assert.AreEqual(0, array1.Count); Assert.AreEqual(0, array1.Capacity); Assert.AreEqual(Cardinal(sizeof(InnerT)), array1.ItemSize); array1.Clear(); Assert.AreEqual(0, array1.Count); Assert.AreEqual(0, array1.Capacity); Assert.AreEqual(Cardinal(sizeof(InnerT)), array1.ItemSize); array1.ClearMem(); Assert.AreEqual(0, array1.Count); Assert.AreEqual(0, array1.Capacity); Assert.AreEqual(Cardinal(sizeof(InnerT)), array1.ItemSize); array1.Hold; Assert.AreEqual(0, array1.Count); Assert.AreEqual(0, array1.Capacity); Assert.AreEqual(Cardinal(sizeof(InnerT)), array1.ItemSize); array1.Zero; Assert.AreEqual(0, array1.Count); Assert.AreEqual(0, array1.Capacity); Assert.AreEqual(Cardinal(sizeof(InnerT)), array1.ItemSize); end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestEmpty2; var val: InnerT; begin Assert.AreEqual(0, array1.Count); 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, 'g0'); Assert.WillRaise(procedure begin array1.Get(0, @val) end, ERangeError, 'g0'); Assert.WillRaise(procedure begin array1.Get(1, @val) end, ERangeError, 'g1'); Assert.WillRaise(procedure begin array1.Get(2, @val) end, ERangeError, 'g2'); Assert.WillRaise(procedure begin array1.Get(10000, @val) end, ERangeError, 'g10000'); Assert.WillRaise(procedure begin array1.Update(0, nil) end, ERangeError, 'u0'); Assert.WillRaise(procedure begin array1.Update(0, @val) end, ERangeError, 'u0'); Assert.WillRaise(procedure begin array1.Update(1, @val) end, ERangeError, 'u1'); Assert.WillRaise(procedure begin array1.Update(2, @val) end, ERangeError, 'u2'); Assert.WillRaise(procedure begin array1.Update(10000, @val) end, ERangeError, 'u10000'); Assert.AreEqual(0, array1.Count); array1.UpdateMany(0, nil, 0); Assert.WillRaise(procedure begin array1.UpdateMany(0, nil, 1);end, EAssertionFailed); Assert.WillRaise(procedure begin array1.UpdateMany(0, nil, 2);end, EAssertionFailed); array1.UpdateMany(1, nil, 0); Assert.WillRaise(procedure begin array1.UpdateMany(1, nil, 1);end, EAssertionFailed); Assert.WillRaise(procedure begin array1.UpdateMany(1, nil, 2);end, EAssertionFailed); array1.UpdateMany(2, nil, 0); Assert.WillRaise(procedure begin array1.UpdateMany(2, nil, 1);end, EAssertionFailed); Assert.WillRaise(procedure begin array1.UpdateMany(0, nil, 2);end, EAssertionFailed); Assert.AreEqual(0, array1.Count); array1.UpdateMany(0, @val, 0); Assert.WillRaise(procedure begin array1.UpdateMany(0, @val, 1); end, ERangeError); Assert.WillRaise(procedure begin array1.UpdateMany(0, @val, 2); end, ERangeError); array1.UpdateMany(1, @val, 0); Assert.WillRaise(procedure begin array1.UpdateMany(1, @val, 1); end, ERangeError); Assert.WillRaise(procedure begin array1.UpdateMany(1, @val, 2); end, ERangeError); array1.UpdateMany(10, @val, 0); Assert.WillRaise(procedure begin array1.UpdateMany(10, @val, 1); end, ERangeError); Assert.WillRaise(procedure begin array1.UpdateMany(10, @val, 9); end, ERangeError); Assert.WillRaise(procedure begin array1.UpdateMany(1, @val, 1); end, ERangeError); Assert.WillRaise(procedure begin array1.UpdateMany(10, @val, 5); end, ERangeError); Assert.AreEqual(0, array1.Count); array1.UpdateMany(0, @val, 1, True); // will expand array size to required value Assert.AreEqual(1, array1.Count); end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestCountOne; var val, val2, valTmp: InnerT; begin val := 66; val2 := 99; array1.Add(@val); Assert.AreEqual(1, array1.Count); Assert.AreEqual(4, array1.Capacity); Assert.AreEqual(Cardinal(sizeof(val)), array1.ItemSize); array1.Delete(0); array1.Add(@val); 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); Assert.AreEqual<InnerT>(val, valTmp); Assert.WillRaise(procedure begin array1.Update(1, nil) end, ERangeError, 'g1 nil'); Assert.WillRaise(procedure begin array1.Get(1, @valTmp) end, ERangeError, 'g1'); Assert.WillRaise(procedure begin array1.Get(2, @valTmp) end, ERangeError, 'g2'); Assert.WillRaise(procedure begin array1.Get(10000, @valTmp) end, ERangeError, 'g10000'); Assert.AreEqual(1, array1.Count); Assert.AreEqual(4, array1.Capacity); Assert.WillNotRaiseAny(procedure begin array1.Update(0, @val2) end); Assert.WillRaise(procedure begin array1.Update(1, nil) end, ERangeError, 'u1 nil'); Assert.WillRaise(procedure begin array1.Update(1, @val) end, ERangeError, 'u1'); Assert.WillRaise(procedure begin array1.Update(2, @val) end, ERangeError, 'u2'); Assert.WillRaise(procedure begin array1.Update(10000, @val) end, ERangeError, 'u10000'); Assert.AreEqual(1, array1.Count); Assert.AreEqual(4, array1.Capacity); end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestUpdate; var val, val2, val3, valTmp: InnerT; newVal0, newVal1, newVal2: InnerT; begin val := 66; val2 := 99; val3 := 120; array1.Insert(0, @val); array1.Insert(1, @val2); array1.Insert(2, @val3); array1.Get(0, @valTmp); Assert.AreEqual<InnerT>(val, valTmp); array1.Get(1, @valTmp); Assert.AreEqual<InnerT>(val2, valTmp); array1.Get(2, @valTmp); Assert.AreEqual<InnerT>(val3, valTmp); newVal0 := 1; newVal1 := 22; newVal2 := 114; array1.Update(0, @newVal0); array1.Get(0, @valTmp); Assert.AreEqual<InnerT>(newVal0, valTmp); array1.Get(1, @valTmp); Assert.AreEqual<InnerT>(val2, valTmp); array1.Get(2, @valTmp); Assert.AreEqual<InnerT>(val3, valTmp); array1.Update(1, @newVal1); array1.Get(0, @valTmp); Assert.AreEqual<InnerT>(newVal0, valTmp); array1.Get(1, @valTmp); Assert.AreEqual<InnerT>(newVal1, valTmp); array1.Get(2, @valTmp); Assert.AreEqual<InnerT>(val3, valTmp); array1.Update(2, @newVal2); array1.Get(0, @valTmp); Assert.AreEqual<InnerT>(newVal0, valTmp); array1.Get(1, @valTmp); Assert.AreEqual<InnerT>(newVal1, valTmp); array1.Get(2, @valTmp); Assert.AreEqual<InnerT>(newVal2, valTmp); array1.Update(2, nil); //when pValue=nil Update methods fills value with zeros array1.Get(0, @valTmp); Assert.AreEqual<InnerT>(newVal0, valTmp); array1.Get(1, @valTmp); Assert.AreEqual<InnerT>(newVal1, valTmp); array1.Get(2, @valTmp); Assert.AreEqual<InnerT>(0, valTmp); Assert.AreEqual(3, array1.Count); Assert.AreEqual(4, array1.Capacity); Assert.WillRaise(procedure begin array1.Update(3, @newVal0) end, ERangeError, 'g1'); Assert.WillRaise(procedure begin array1.Update(4, @newVal0) end, ERangeError, 'g2'); Assert.WillRaise(procedure begin array1.Update(1000, @newVal0) end, ERangeError, 'g10000'); Assert.AreEqual(3, array1.Count); Assert.AreEqual(4, array1.Capacity); end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestUpdateMany; var val1, val2, val3, valTmp: InnerT; newVal0, newVal1, newVal2: InnerT; newValues: TArray<InnerT>; begin val1 := 66; val2 := 99; val3 := 126; array1.UpdateMany(0, nil, 0); //// if Count=0 then pValue is not checked for nil array1.UpdateMany(1, nil, 0); Assert.WillRaise(procedure begin array1.UpdateMany(0, nil, 1); end, EAssertionFailed, 'um nil 1'); Assert.WillRaise(procedure begin array1.UpdateMany(1, nil, 1); end, EAssertionFailed, 'um nil 1'); array1.Insert(0, @val1); array1.Insert(1, @val2); array1.Insert(2, @val3); array1.UpdateMany(2, nil, 0); Assert.WillRaise(procedure begin array1.UpdateMany(0, nil, 4); end, EAssertionFailed, 'um nil 1'); Assert.WillRaise(procedure begin array1.UpdateMany(1, nil, 4); end, EAssertionFailed, 'um nil 1'); Assert.WillRaise(procedure begin array1.UpdateMany(3, nil, 1); end, EAssertionFailed, 'um nil 1'); newVal0 := 1; newVal1 := 22; newVal2 := 114; array1.UpdateMany(0, @newVal0, 0); array1.UpdateMany(0, @newVal0, 1); array1.Get(0, @valTmp); Assert.AreEqual<InnerT>(newVal0, valTmp); array1.Get(1, @valTmp); Assert.AreEqual<InnerT>(val2, valTmp); array1.Get(2, @valTmp); Assert.AreEqual<InnerT>(val3, valTmp); Assert.AreEqual(3, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.UpdateMany(1, @newVal1, 0); array1.UpdateMany(1, @newVal1, 1); array1.Get(0, @valTmp); Assert.AreEqual<InnerT>(newVal0, valTmp); array1.Get(1, @valTmp); Assert.AreEqual<InnerT>(newVal1, valTmp); array1.Get(2, @valTmp); Assert.AreEqual<InnerT>(val3, valTmp); Assert.AreEqual(3, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.UpdateMany(2, @newVal2, 0); array1.UpdateMany(2, @newVal2, 1); array1.Get(0, @valTmp); Assert.AreEqual<InnerT>(newVal0, valTmp); array1.Get(1, @valTmp); Assert.AreEqual<InnerT>(newVal1, valTmp); array1.Get(2, @valTmp); Assert.AreEqual<InnerT>(newVal2, valTmp); Assert.AreEqual(3, array1.Count); Assert.AreEqual(4, array1.Capacity); SetLength(newValues, 5); newValues[0] := val1; newValues[1] := val2; newValues[2] := val3; newValues[3] := val1; newValues[4] := val2; //UpdateMany generates error 'Index not found' when tries to write data beyong array boundaries and last parameter is False (it is by default) Assert.WillRaise(procedure begin array1.UpdateMany(1, @(newValues[0]), 5); end, ERangeError, 'rang error 1'); // will automatically expand array size to fit all updated data array1.UpdateMany(1, @(newValues[0]), 5, True); Assert.AreEqual(6, array1.Count); Assert.AreEqual(8, array1.Capacity); array1.Get(0, @valTmp); Assert.AreEqual<InnerT>(newVal0, valTmp); array1.Get(1, @valTmp); Assert.AreEqual<InnerT>(val1, valTmp); array1.Get(2, @valTmp); Assert.AreEqual<InnerT>(val2, valTmp); array1.Get(3, @valTmp); Assert.AreEqual<InnerT>(val3, valTmp); array1.Get(4, @valTmp); Assert.AreEqual<InnerT>(val1, valTmp); array1.Get(5, @valTmp); Assert.AreEqual<InnerT>(val2, valTmp); Assert.AreEqual(6, array1.Count); Assert.AreEqual(8, array1.Capacity); Assert.WillRaise(procedure begin array1.UpdateMany(6, @newVal0, 1) end, ERangeError, 'g1'); Assert.WillRaise(procedure begin array1.UpdateMany(10, @newVal0, 1) end, ERangeError, 'g2'); Assert.WillRaise(procedure begin array1.UpdateMany(1000, @newVal0, 1000) end, ERangeError, 'g1000'); Assert.WillRaise(procedure begin array1.UpdateMany(0, @newVal0, 1000) end, ERangeError, 'g0_1000'); Assert.AreEqual(6, array1.Count); Assert.AreEqual(8, array1.Capacity); end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestZero; var val, val2, val3, valTmp: InnerT; newVal: InnerT; 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); val := 66; val2 := 99; val3 := 123; array1.Insert(0, @val); array1.Insert(1, @val2); array1.Insert(2, @val3); Assert.AreEqual(3, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.Get(0, @valTmp); Assert.AreEqual<InnerT>(val, valTmp); array1.Get(1, @valTmp); Assert.AreEqual<InnerT>(val2, valTmp); array1.Get(2, @valTmp); Assert.AreEqual<InnerT>(val3, valTmp); array1.Zero; Assert.AreEqual(3, array1.Count); Assert.AreEqual(4, array1.Capacity); newVal := 0; array1.Get(0, @valTmp); Assert.AreEqual<InnerT>(newVal, valTmp); array1.Get(1, @valTmp); Assert.AreEqual<InnerT>(newVal, valTmp); array1.Get(2, @valTmp); Assert.AreEqual<InnerT>(newVal, valTmp); val := 1; val2 := 22; val3 := 124; array1.Insert(1, @val); array1.Get(1, @valTmp); Assert.AreEqual<InnerT>(val, valTmp); array1.Insert(3, @val2); array1.Get(3, @valTmp); Assert.AreEqual<InnerT>(val2, valTmp); array1.Insert(5, @val3); array1.Get(5, @valTmp); Assert.AreEqual<InnerT>(val3, valTmp); array1.Zero; newVal := 0; for i := 0 to 5 do begin array1.Get(i, @valTmp); Assert.AreEqual<InnerT>(newVal, valTmp); end; Assert.AreEqual(6, array1.Count); Assert.AreEqual(8, array1.Capacity); end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestSwap; var val0, val1, val2, valTmp: InnerT; begin val0 := 66; val1 := 99; val2 := 125; array1.Insert(0, @val0); array1.Insert(1, @val1); array1.Add(@val2); Assert.AreEqual(3, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.Get(0, @valTmp); Assert.AreEqual<InnerT>(val0, valTmp); array1.Get(1, @valTmp); Assert.AreEqual<InnerT>(val1, valTmp); array1.Get(2, @valTmp); Assert.AreEqual<InnerT>(val2, valTmp); array1.Swap(0, 1); array1.Get(0, @valTmp); Assert.AreEqual<InnerT>(val1, valTmp); array1.Get(1, @valTmp); Assert.AreEqual<InnerT>(val0, valTmp); array1.Get(2, @valTmp); Assert.AreEqual<InnerT>(val2, valTmp); array1.Swap(0, 1); array1.Get(0, @valTmp); Assert.AreEqual<InnerT>(val0, valTmp); array1.Get(1, @valTmp); Assert.AreEqual<InnerT>(val1, valTmp); array1.Get(2, @valTmp); Assert.AreEqual<InnerT>(val2, valTmp); array1.Swap(1, 1); array1.Get(0, @valTmp); Assert.AreEqual<InnerT>(val0, valTmp); array1.Get(1, @valTmp); Assert.AreEqual<InnerT>(val1, valTmp); array1.Get(2, @valTmp); Assert.AreEqual<InnerT>(val2, valTmp); array1.Swap(2, 2); array1.Get(0, @valTmp); Assert.AreEqual<InnerT>(val0, valTmp); array1.Get(1, @valTmp); Assert.AreEqual<InnerT>(val1, valTmp); array1.Get(2, @valTmp); Assert.AreEqual<InnerT>(val2, valTmp); array1.Swap(1, 0); array1.Get(0, @valTmp); Assert.AreEqual<InnerT>(val1, valTmp); array1.Get(1, @valTmp); Assert.AreEqual<InnerT>(val0, valTmp); array1.Get(2, @valTmp); Assert.AreEqual<InnerT>(val2, valTmp); array1.Swap(0, 2); array1.Get(0, @valTmp); Assert.AreEqual<InnerT>(val2, valTmp); array1.Get(1, @valTmp); Assert.AreEqual<InnerT>(val0, valTmp); array1.Get(2, @valTmp); Assert.AreEqual<InnerT>(val1, valTmp); array1.Swap(2, 1); array1.Get(0, @valTmp); Assert.AreEqual<InnerT>(val2, valTmp); array1.Get(1, @valTmp); Assert.AreEqual<InnerT>(val1, valTmp); array1.Get(2, @valTmp); Assert.AreEqual<InnerT>(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(10, 10); end, ERangeError, 'index out of bounds 6'); Assert.WillRaise(procedure begin array1.Swap(11, 109); end, ERangeError, 'index out of bounds 7'); end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestDeleteValue1; var I: Integer; v, v2: InnerT; begin for I := 0 to 9 do begin v := i + 1; array1.Add(@v); array2.Add(@v); 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); v2 := i + 2; Assert.AreEqual<InnerT>(v2, v); end; Assert.WillRaise(procedure begin array1.Delete(array1.Count); end, ERangeError, 'DeleteCalue 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); v2 := i + 2; Assert.AreEqual<InnerT>(v, v2) end; end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestDeleteValue2; var I: Integer; v: InnerT; begin for I := 1 to 5 do begin v := i + 1; array1.Add(@v); 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, 'DeleteCalue at 0'); // try to delete out of range element Assert.WillRaise(procedure begin array1.Delete(0); end, ERangeError, 'DeleteCalue at 0'); // try to delete out of range element for I := 1 to 5 do begin v := i + 1; array1.Add(@v); end; Assert.AreEqual(5, array1.Count); Assert.AreEqual(8, array1.Capacity); array1.Delete(1); Assert.AreEqual(4, array1.Count); Assert.AreEqual(8, array1.Capacity); array1.Delete(1); Assert.AreEqual(3, array1.Count); Assert.AreEqual(8, array1.Capacity); array1.Delete(1); Assert.AreEqual(2, array1.Count); Assert.AreEqual(8, array1.Capacity); array1.Delete(1); Assert.AreEqual(1, array1.Count); Assert.AreEqual(8, array1.Capacity); Assert.WillRaise(procedure begin array1.Delete(1); end, ERangeError, 'DeleteCalue 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 v := i + 1; array1.Add(@v); 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, 'DeleteCalue at 0'); // try to delete out of range element Assert.AreEqual(0, array1.Count); Assert.AreEqual(8, array1.Capacity); end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestIndexOf1; var v, vv, vvv: InnerT; begin v := 77; // CreateValue<TT>(777); vv := 4; //CreateValue<TT>(4); vvv := 0; //CreateValue<TT>(0); Assert.AreEqual(-1, array1.IndexOf(nil)); Assert.AreEqual(-1, array1.IndexOf(@v)); 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)); Assert.AreEqual(-1, array1.IndexOfFrom(@v, 1)); Assert.AreEqual(-1, array1.IndexOfFrom(@v, 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@v, 1000)); Assert.AreEqual(-1, array1.IndexOfFrom(@vv, 0)); Assert.AreEqual(-1, array1.IndexOfFrom(@vv, 1)); Assert.AreEqual(-1, array1.IndexOfFrom(@vv, 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@vv, 1000)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv, 0)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv, 1)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv, 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv, 1000)); end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestIndexOf2(AValue1, AValue2, AValue3, AValue4: Integer); var v1, v2, v3, vcmp: InnerT; Ind: Cardinal; // bvvv : Boolean absolute v3; begin Assert.AreNotEqual(AValue1, AValue2, 'AValue1 and AValue2 must not be equal in TestIndexOf2()!'); Assert.AreNotEqual(AValue1, AValue3, 'AValue1 and AValue3 must not be equal in TestIndexOf2()!'); Assert.AreNotEqual(AValue2, AValue3, 'AValue2 and AValue3 must not be equal in TestIndexOf2()!'); if IsTTUnsigned AND (AValue1 < 0) then AValue1 := -AValue1; // this is mostly for Byte and ShortInt types if IsTTUnsigned AND (AValue2 < 0) then AValue2 := -AValue2; if IsTTUnsigned AND (AValue3 < 0) then AValue3 := -AValue3; v1 := AValue1; v2 := AValue2; v3 := AValue3; Ind := array1.Add(@v1); Assert.AreEqual(0, Ind); array1.Get(Ind, @vcmp); Assert.AreEqual<InnerT>(v1, vcmp); Assert.AreEqual(array1.IndexOf(@vcmp), array1.IndexOf(@v1)); Ind := array1.Add(@v2); Assert.AreEqual(1, Ind); array1.Get(Ind, @vcmp); Assert.AreEqual<InnerT>(v2, vcmp); Assert.AreEqual(array1.IndexOf(@vcmp), array1.IndexOf(@v2)); Ind := array1.Add(@v3); Assert.AreEqual(2, Ind); array1.Get(Ind, @vcmp); Assert.AreEqual<InnerT>(v3, vcmp); Assert.AreEqual(array1.IndexOf(@vcmp), array1.IndexOf(@v3)); { if IsTTBoolean() then begin Assert.AreEqual(AValue4, array1.IndexOfFrom(true, 0)); // Assert.AreEqual(AValue4, array1.IndexOfFrom(true, 1)); Assert.AreEqual(-1, array1.IndexOfFrom(true, 2)); Assert.AreEqual(-1, array1.IndexOfFrom(true, 333)); Assert.AreEqual(AValue4, array1.IndexOfFrom(true, 0)); // Assert.AreEqual(AValue4, array1.IndexOfFrom(vv, 1)); Assert.AreEqual(-1, array1.IndexOfFrom(true, 2)); Assert.AreEqual(-1, array1.IndexOfFrom(true, 333)); Assert.AreEqual(true, bvvv); Assert.AreEqual(AValue4, array1.IndexOf(vvv)); Assert.AreEqual(AValue4, array1.IndexOfFrom(vvv, 0)); Assert.AreEqual(-1, array1.IndexOfFrom(vvv, 2)); Assert.AreEqual(-1, array1.IndexOfFrom(vvv, 333)); end else begin } // classes (e.g. TObject) cannot be compared by Assert.AreEqual<TT> because it calls v.Equals(vv) // while v and vv are fake instances of TObject and calling any method raises an exception // if GetTypeKind(TT) = tkClass // then Assert.AreEqual(CreateInteger<TT>(v), CreateInteger<TT>(vv)) // else Assert.AreEqual(0, array1.IndexOf(@v1)); Assert.AreEqual(0, array1.IndexOfFrom(@v1, 0)); Assert.AreEqual(-1, array1.IndexOfFrom(@v1, 1)); Assert.AreEqual(-1, array1.IndexOfFrom(@v1, 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@v1, 333)); Assert.AreEqual(1, array1.IndexOf(@v2)); Assert.AreEqual(1, array1.IndexOfFrom(@v2, 0)); Assert.AreEqual(1, array1.IndexOfFrom(@v2, 1)); Assert.AreEqual(-1, array1.IndexOfFrom(@v2, 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@v2, 3)); Assert.AreEqual(-1, array1.IndexOfFrom(@v2, 333)); Assert.AreEqual(2, array1.IndexOf(@v3)); Assert.AreEqual(2, array1.IndexOfFrom(@v3, 0)); Assert.AreEqual(2, array1.IndexOfFrom(@v3, 1)); Assert.AreEqual(2, array1.IndexOfFrom(@v3, 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@v3, 3)); Assert.AreEqual(-1, array1.IndexOfFrom(@v3, 4)); Assert.AreEqual(-1, array1.IndexOfFrom(@v3, 333)); // end; {if GetTypeKind(TT) = tkClass then begin // for non-Class types nil is converted into 0 (zero) and produces incorrect assert results when AValue1 or Avalue2 is also = 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, 555)); end;} end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestInsert1; var I: Integer; val, val2: InnerT; begin for I := 0 to 99 do begin val := i + 1000; array1.Insert(0, @val); array2.Insert(0, @val); 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); val2 := 1100 - I - 1; Assert.AreEqual<InnerT>(val2, val); end end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestInsert2; var //I: Integer; v1, v2,v3, vv: InnerT; begin v1 := 111; v2 := 122; v3 := 3; array1.Add(@v1); Assert.AreEqual(4, array1.Capacity); array1.Add(@v3); Assert.AreEqual(4, array1.Capacity); array1.Insert(1, @v2); Assert.AreEqual(4, array1.Capacity); array1.Get(0, @v1); vv := 111; Assert.AreEqual<InnerT>(vv, v1); array1.Get(1, @v1); vv := 122; Assert.AreEqual<InnerT>(vv, v1); array1.Get(2, @v1); vv := 3; Assert.AreEqual<InnerT>(vv, v1); end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestQuickFind(AValue1, AValue2, AValue3: string); var token: string; I, Cnt: Integer; FindVal, valTmp: InnerT; begin //TODO: Assert.IsTrue(StrToInt(Trim(AValue2)) >= 0); Cnt := HGetTokenCount(AValue1, ';', False); for I := 1 to Cnt do begin token := HGetToken(AValue1, ';', False, i - 1); valTmp := StrToInt(Trim(token)); array1.Add(@valTmp); end; array1.QuickSort(Compare1); VerifySorting(array1); FindVal := StrToInt(Trim(AValue2)); Assert.AreEqual(StrToInt(Trim(AValue3)), array1.QuickFind(FindProc, @FindVal)); end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestQuickSort1; var v, v2: InnerT; begin Assert.AreEqual(0, array1.Count); array1.QuickSort(nil); // array is empty so QuickSort will NOT generate an exception that CompareProc is not set. v := 9; array1.Add(@v); array1.QuickSort(nil); // array contains one element so QuickSort will NOT generate an exception that CompareProc is not set. array1.Add(@v); 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 := 4; array1.Add(@v); v := 3; array1.Add(@v); v := 5; array1.Add(@v); v := 7; array1.Add(@v); array1.QuickSort(Compare1); array1.Get(0, @v); v2 := 3; Assert.AreEqual<InnerT>(v2, v); array1.Get(1, @v); v2 := 4; Assert.AreEqual<InnerT>(v2, v); array1.Get(2, @v); v2 := 5; Assert.AreEqual<InnerT>(v2, v); array1.Get(3, @v); v2 := 7; Assert.AreEqual<InnerT>(v2, v); array1.Clear; v := 4; array1.Add(@v); v := 3; array1.Add(@v); v := 7; array1.Add(@v); v := 6; array1.Add(@v); array1.QuickSort(Compare1); array1.Get(0, @v); v2 := 3; Assert.AreEqual<InnerT>(v2, v); array1.Get(1, @v); v2 := 4; Assert.AreEqual<InnerT>(v2, v); array1.Get(2, @v); v2 := 6; Assert.AreEqual<InnerT>(v2, v); array1.Get(3, @v); v2 := 7; Assert.AreEqual<InnerT>(v2, v); end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestQuickSort2(AValue1, AValue2: string); var Cnt: Integer; I: Integer; token: string; v: InnerT; // cmp: IComparer<TTestArr>; begin // cmp := TComparer<TTestArr>.Default; Cnt := HGetTokenCount(AValue1, ';', False); for I := 1 to Cnt do begin token := HGetToken(AValue1, ';', False, i - 1); v := StrToInt(Trim(token)); array1.Add(@v); end; array1.QuickSort(Compare1); VerifySorting(array1); Assert.Pass('TestQuickSort2: success.'); end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestSort1; var s1: TSortMethod; begin s1 := array1.BubbleSort; TestSort1(s1); s1 := array1.SelectionSort; TestSort1(s1); // s1 := array1.InsertSort; // TestSort1(s1); s1 := array1.ShakerSort; TestSort1(s1); s1 := array1.QuickSort; TestSort1(s1); end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestSort1(Method: TSortMethod); var v, v3, v4, v5, v7: InnerT; begin array1.Clear; // do not remove it. Assert.AreEqual(0, array1.Count); Method(nil); // no exception if CompareProc=nil and array contains <2 elements v5 := 5; array1.Add(@v5); Assert.AreEqual(1, array1.Count); Method(nil); // no exception if CompareProc=nil and array contains <2 elements array1.Clear; Assert.AreEqual(0, array1.Count); Method(Compare1); Assert.AreEqual(0, array1.Count); v5 := 5; array1.Add(@v5); Assert.AreEqual(1, array1.Count); Method(Compare1); Method(nil); array1.Clear; v4 := 4; v3 := 3; v7 := 7; v5 := 5; array1.Add(@v4); array1.Add(@v3); array1.Add(@v7); array1.Add(@v5); Assert.AreEqual(4, array1.Count); Assert.WillRaise(procedure begin Method(nil); end, EArgumentException); try Method(nil); Assert.Fail('We should not be here!'); except on E:EArgumentException do Assert.AreEqual('Cannot sort without CompareProc!', E.Message); end; Method(Compare1); array1.Get(0, @v); Assert.AreEqual<InnerT>(v3, v); array1.Get(1, @v); Assert.AreEqual<InnerT>(v4, v); array1.Get(2, @v); Assert.AreEqual<InnerT>(v5, v); array1.Get(3, @v); Assert.AreEqual<InnerT>(v7, v); VerifySorting(array1); // using two ways to verify sorting array1.Clear; Assert.AreEqual(0, array1.Count); array1.Add(@v4); array1.Add(@v3); array1.Add(@v7); array1.Add(@v5); Assert.AreEqual(4, array1.Count); Method(Compare1); VerifySorting(array1); // using two ways to verify sorting array1.Get(0, @v); Assert.AreEqual<InnerT>(v3, v); array1.Get(1, @v); Assert.AreEqual<InnerT>(v4, v); array1.Get(2, @v); Assert.AreEqual<InnerT>(v5, v); array1.Get(3, @v); Assert.AreEqual<InnerT>(v7, v); array1.Clear; array1.Add(@v4); array1.Add(@v3); array1.Add(@v7); array1.Add(@v4); array1.Add(@v5); Assert.AreEqual(5, array1.Count); array1.Get(0, @v); Assert.AreEqual<InnerT>(v3, v); array1.Get(1, @v); Assert.AreEqual<InnerT>(v4, v); array1.Get(2, @v); Assert.AreEqual<InnerT>(v4, v); array1.Get(3, @v); Assert.AreEqual<InnerT>(v5, v); array1.Get(3, @v); Assert.AreEqual<InnerT>(v7, v); VerifySorting(array1); // using two ways to verify sorting end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestSort2(AValue1, AValue2: string); var srt: TSortMethod; begin srt := array1.BubbleSort; TestSort2(srt, AValue1, AValue2); srt := array1.SelectionSort; TestSort2(srt, AValue1, AValue2); //srt := array1.InsertSort; //TestSort2(srt, AValue1, AValue2); srt := array1.ShakerSort; TestSort2(srt, AValue1, AValue2); srt := array1.QuickSort; TestSort2(srt, AValue1, AValue2); end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestSort2(Method: TSortMethod; AValue1, AValue2: string); var token: string; valTmp: InnerT; I, val: Integer; begin array1.Clear; //do not remove it for I := 1 to HGetTokenCount(AValue1, ';', False) do begin token := HGetToken(AValue1, ';', False, i - 1); val := StrToInt(Trim(token)); if IsTTUnsigned AND (val < 0) then val := -val; // this is mostly for Byte and ShortInt types valTmp := val; array1.Add(@valTmp); end; Method(Compare1); VerifySorting(array1); // if Avalue1 and Avalue2 contain only one value then there are no any Asserts called // 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 TDynamicArraysBaseTest<TT, InnerT>.VerifySorting(arr: TT); var i: Cardinal; v, vv: InnerT; cmp: IComparer<InnerT>; begin cmp := TComparer<InnerT>.Default; for i := 1 to arr.Count - 1 do begin arr.Get(i - 1, @v); arr.Get(i, @vv); Assert.IsTrue(cmp.Compare(v, vv) <= 0, '*** Array is NOT sorted ***'); end; Assert.Pass('VerifySorting: Array is properly sorted.'); end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestBubbleSortPerformance; var i: Integer; r: InnerT; begin array1.SetCapacity(ARRAYSIZE_FOR_SORTING); Assert.AreEqual(Cardinal(sizeof(InnerT)), array1.ItemSize); var start1 := GetTickCount; for i := 0 to ARRAYSIZE_FOR_SORTING - 1 do begin r := random(GetValueForRandom(array1)); array1.Add(@r); end; TDUnitX.CurrentRunner.Log(Format('Generate random data = %s', [MillisecToStr(GetTickCount - start1)])); var start2 := GetTickCount; array1.BubbleSort(Compare1); TDUnitX.CurrentRunner.Log(Format('BubbleSort(%d) = %s', [ARRAYSIZE_FOR_SORTING, MillisecToStr(GetTickCount - start2)])); VerifySorting(array1); //Assert.Pass(); end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestSelectionSortPerformance; var i: Integer; r: InnerT; begin array1.SetCapacity(ARRAYSIZE_FOR_SORTING); for i := 0 to ARRAYSIZE_FOR_SORTING - 1 do begin r := random(GetValueForRandom(array1)); array1.Add(@r{CreateValue<TT>(r)}); end; var start := GetTickCount; array1.SelectionSort(Compare1); TDUnitX.CurrentRunner.Log(Format('SelectionSort(%d) = %s', [ARRAYSIZE_FOR_SORTING, MillisecToStr(GetTickCount - start)])); VerifySorting(array1); end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestShakerSortPerformance; var i: Integer; r: InnerT; begin array1.SetCapacity(ARRAYSIZE_FOR_SORTING); for i := 0 to ARRAYSIZE_FOR_SORTING - 1 do begin r := random(GetValueForRandom(array1)); array1.Add(@r{CreateValue<TT>(r)}); end; var start := GetTickCount; array1.ShakerSort(Compare1); TDUnitX.CurrentRunner.Log(Format('ShakerSort(%d) = %s', [ARRAYSIZE_FOR_SORTING, MillisecToStr(GetTickCount - start)])); VerifySorting(array1); end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestQuickSortPerformance; var i: Integer; r: InnerT; begin array1.SetCapacity(ARRAYSIZE_FOR_SORTING); for i := 0 to ARRAYSIZE_FOR_SORTING - 1 do begin r := random(GetValueForRandom(array1)); array1.Add(@r{CreateValue<TT>(r)}); end; var start := GetTickCount; array1.QuickSort(Compare1); TDUnitX.CurrentRunner.Log(Format('QuickSort(%d) = %s', [ARRAYSIZE_FOR_SORTING, MillisecToStr(GetTickCount - start)])); VerifySorting(array1); end; { procedure TDynamicArraysBaseTest<TT, InnerT>.TestInsertSortPerformance; var i: Integer; r: InnerT; begin array1.SetCapacity(ARRAYSIZE_FOR_SORTING); for i := 0 to ARRAYSIZE_FOR_SORTING - 1 do begin r := random(10_000); array1.Add(@r); end; var start := GetTickCount; array1.InsertSort(Compare1); TDUnitX.CurrentRunner.Log(Format('InsertSort(%d) = %s', [ARRAYSIZE_FOR_SORTING, MillisecToStr(GetTickCount - start)])); VerifySorting(array1); end; } procedure TDynamicArraysBaseTest<TT, InnerT>.CopyArray(arr1, arr2: TTestingArrayType); var i: Cardinal; v: InnerT; begin arr2.Clear; arr2.SetCapacity(arr1.Capacity); for i := 0 to arr1.Count - 1 do begin arr1.Get(i, @v); arr2.Add(@v); end; end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestAllSortAlgsPerformance; var i: Integer; r: InnerT; begin array1.SetCapacity(ARRAYSIZE_FOR_SORTING); // same initial array for all algs for i := 0 to ARRAYSIZE_FOR_SORTING - 1 do begin r := random(GetValueForRandom(array1)); array1.Add(@r); end; // we will be sorting array2 CopyArray(array1, array2); var start := GetTickCount; array2.BubbleSort(Compare1); TDUnitX.CurrentRunner.Log(Format('BubbleSort(%d) = %s', [ARRAYSIZE_FOR_SORTING, MillisecToStr(GetTickCount - start)])); VerifySorting(array2); CopyArray(array1, array2); start := GetTickCount; array2.SelectionSort(Compare1); TDUnitX.CurrentRunner.Log(Format('SelectingSort(%d) = %s', [ARRAYSIZE_FOR_SORTING, MillisecToStr(GetTickCount - start)])); VerifySorting(array2); {CopyArray(array1, array2); start := GetTickCount; array2.InsertSort(Compare1); TDUnitX.CurrentRunner.Log(Format('InsertSort(%d) = %s', [ARRAYSIZE_FOR_SORTING, MillisecToStr(GetTickCount - start)])); VerifySorting(array2);} CopyArray(array1, array2); start := GetTickCount; array2.ShakerSort(Compare1); TDUnitX.CurrentRunner.Log(Format('ShakerSort(%d) = %s', [ARRAYSIZE_FOR_SORTING, MillisecToStr(GetTickCount - start)])); VerifySorting(array2); CopyArray(array1, array2); start := GetTickCount; array2.QuickSort(Compare1); TDUnitX.CurrentRunner.Log(Format('QuiuckSort(%d) = %s', [ARRAYSIZE_FOR_SORTING, MillisecToStr(GetTickCount - start)])); VerifySorting(array2); end; procedure TDynamicArraysBaseTest<TT, InnerT>.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 TDynamicArraysBaseTest<TT, InnerT>.TestCapacity2; var i: Integer; v: InnerT; begin for i := 0 to 499 do begin v := i mod 127; // required for testing THarrayByte and THarrayShortInt array1.Add(@v); 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 TDynamicArraysBaseTest<TT, InnerT>.Compare1(arr: THArray; i, j: Cardinal): Integer; const cmp: IComparer<InnerT> = nil; // analogue of static variable which saves its value between function calls var v1, v2: InnerT; begin if cmp = nil then cmp := TComparer<InnerT>.Default; // should be called only once // Assert.IsTrue(i < MAXINT); // Assert.IsTrue(arr.Count < MAXINT); // Assert.IsTrue(i < arr.Count); arr.Get(i, @v1); arr.Get(j, @v2); // Assert.IsTrue(Assigned(cmp)); Result := cmp.Compare(v1, v2); end; function TDynamicArraysBaseTest<TT, InnerT>.FindProc(arr: THArray; i: Cardinal; FindData: Pointer): Integer; const cmp: IComparer<InnerT> = nil; // analogue of static variable which saves its value between function calls type PInnerT = ^InnerT; var v1, v2: InnerT; begin if cmp = nil then cmp := TComparer<InnerT>.Default; // should be called only once v1 := PInnerT(FindData)^; arr.Get(i, @v2); Result := cmp.Compare(v1, v2); end; function TDynamicArraysBaseTest<TT, InnerT>.GetValueForRandom(a: TT): Integer; begin if a.ItemSize >= 2 then Result := 10_000 else Result := 127; end; function TDynamicArraysBaseTest<TT, InnerT>.Compare2(Item1, Item2: InnerT): Integer; const cmp: IComparer<InnerT> = nil; // analogue of static variable which saves its value between function calls begin if cmp = nil then cmp := TComparer<InnerT>.Default; // should be called only once Result := cmp.Compare(Item1, Item2); end; function TDynamicArraysBaseTest<TT, InnerT>.IsTTBoolean: Boolean; var TypeInfoPtr: PTypeInfo; begin TypeInfoPtr := TypeInfo(TT); Result := (GetTypeKind(TT) = tkEnumeration) AND (TypeInfoPtr.Name = 'Boolean'); end; function TDynamicArraysBaseTest<TT, InnerT>.IsTTUnsigned: Boolean; var TypeInfoPtr: PTypeInfo; begin TypeInfoPtr := TypeInfo(InnerT); Result := (GetTypeKind(InnerT) = tkInteger) AND ((TypeInfoPtr.Name = 'Byte') OR (TypeInfoPtr.Name = 'Cardinal') OR (TypeInfoPtr.Name = 'LongWord') OR (TypeInfoPtr.Name = 'Word') OR (TypeInfoPtr.Name = 'NativeUint') OR (TypeInfoPtr.Name = 'UInt64')); end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestAddClearAdd1; var I: Integer; v, v2: InnerT; begin for I := 5 to 9 do begin v := I; array1.Insert(array1.Count, @v); array2.Insert(array2.Count, @v); 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 := I; array1.Insert(array1.Count, @v); array2.Insert(array2.Count, @v); 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); v2 := I + 15; Assert.AreEqual<InnerT>(v2, v); end; for I := 0 to 4 do begin array2.Get(I, @v2); array1.Get(I, @v); Assert.AreEqual<InnerT>(v2, v); end; end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestAddClearAdd2; var I: Integer; v, v2: InnerT; begin // if IsTTUnsigned then exit; for I := -9 to -5 do begin v := I; array1.Insert(array1.Count, @v); array2.Insert(array2.Count, @v); 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 v := I; array1.Insert(array1.Count, @v); array2.Insert(array2.Count, @v); 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); v2 := I - 19; Assert.AreEqual<InnerT>(v2, v); end; for I := 0 to 4 do begin array2.Get(I, @v2); array1.Get(I, @v); Assert.AreEqual<InnerT>(v2, v); end; end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestAddMany; var val, valTmp: InnerT; val1, val2, val3: InnerT; arr: TArray<InnerT>; begin val := 99; array1.AddMany(@val, 0); Assert.AreEqual(0, array1.Count); Assert.AreEqual(0, array1.Capacity); array1.AddMany(nil, 0); // if Count=0 then pValue is not checked for nil Assert.AreEqual(0, array1.Count); Assert.AreEqual(0, array1.Capacity); Assert.WillRaise(procedure begin array1.AddMany(nil, 1);end, EAssertionFailed); Assert.AreEqual(0, array1.Count); Assert.AreEqual(0, array1.Capacity); array1.AddMany(@val, 1); Assert.AreEqual(1, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.Get(0, @valTmp); Assert.AreEqual<InnerT>(val, valTmp); array1.Clear; SetLength(arr, 4); arr[0] := val; arr[1] := val; arr[2] := val; arr[3] := val; array1.AddMany(@(arr[0]), 4); Assert.AreEqual(4, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.Get(0, @valTmp); Assert.AreEqual<InnerT>(val, valTmp); array1.Get(1, @valTmp); Assert.AreEqual<InnerT>(val, valTmp); array1.Get(2, @valTmp); Assert.AreEqual<InnerT>(val, valTmp); array1.Get(3, @valTmp); Assert.AreEqual<InnerT>(val, valTMp); array1.Clear; val1 := 44; //CreateValue<TT>(44); val2 := 105; //CreateValue<TT>(105); val3 := 119; //CreateValue<TT>(909); array1.Add(@val1); array1.Add(@val2); array1.Add(@val3); Assert.AreEqual(3, array1.Count); Assert.AreEqual(4, array1.Capacity); SetLength(arr, 5); arr[4] := val; array1.AddMany(@(arr[0]), 5); Assert.AreEqual(8, array1.Count); Assert.AreEqual(8, array1.Capacity); array1.Get(0, @valTmp); Assert.AreEqual<InnerT>(val1, valTmp); array1.Get(1, @valTmp); Assert.AreEqual<InnerT>(val2, valTmp); array1.Get(2, @valTmp); Assert.AreEqual<InnerT>(val3, valTmp); array1.Get(3, @valTmp); Assert.AreEqual<InnerT>(val, valTmp); array1.Get(4, @valTmp); Assert.AreEqual<InnerT>(val, valTmp); array1.Get(5, @valTmp); Assert.AreEqual<InnerT>(val, valTmp); array1.Get(6, @valTmp); Assert.AreEqual<InnerT>(val, valTmp); array1.Get(7, @valTmp); Assert.AreEqual<InnerT>(val, valTmp); array1.Clear; end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestAddFillValues1; var i: Integer; val, valTmp: InnerT; begin 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); val := 0; Assert.AreEqual<InnerT>(val, valTmp); array1.AddFillValues(4); Assert.AreEqual(5, array1.Count); Assert.AreEqual(8, array1.Capacity); val := 0; for i := 0 to 4 do begin array1.Get(i, @valTmp); Assert.AreEqual<InnerT>(val, valTmp); end; end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestAddFillValues2; var i: Integer; val, valTmp : InnerT; fill: Byte; begin array1.AddFillValues(0, 13); Assert.AreEqual(0, array1.Count); Assert.AreEqual(0, array1.Capacity); fill := 33; array1.AddFillValues(1, fill); Assert.AreEqual(1, array1.Count); Assert.AreEqual(4, array1.Capacity); memset(@val, fill, sizeof(val)); array1.Get(0, @valTmp); Assert.AreEqual<InnerT>(val, valTmp); fill := 55; array1.AddFillValues(4, fill); Assert.AreEqual(5, array1.Count); Assert.AreEqual(8, array1.Capacity); memset(@val, fill, sizeof(val)); for i := 1 to 4 do begin array1.Get(i, @valTmp); Assert.AreEqual<InnerT>(val, valTmp); end; fill := 245; array1.AddFillValues(21, fill); Assert.AreEqual(26, array1.Count); memset(@val, fill, sizeof(val)); for i := 5 to 25 do begin array1.Get(i, @valTmp); Assert.AreEqual<InnerT>(val, valTmp); end; end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestInsertMany; var val, valTmp: InnerT; val1, val2, val3: InnerT; arr: TArray<InnerT>; begin val := 119; array1.InsertMany(0, nil, 0); // if Count=0 then pValue is not checked for nil array1.InsertMany(1, nil, 0); Assert.WillRaise(procedure begin array1.InsertMany(0, nil, 1);end, EAssertionFailed); Assert.WillRaise(procedure begin array1.InsertMany(1, nil, 1);end, EAssertionFailed); array1.InsertMany(0, @val, 0); array1.InsertMany(1, @val, 0); Assert.AreEqual(0, array1.Count); Assert.AreEqual(0, array1.Capacity); array1.InsertMany(0, @val, 1); Assert.AreEqual(1, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.Get(0, @valTmp); Assert.AreEqual<InnerT>(val, valTmp); array1.Clear; SetLength(arr, 4); arr[0] := val; arr[1] := val; arr[2] := val; arr[3] := val; array1.InsertMany(0, @(arr[0]), 4); Assert.AreEqual(4, array1.Count); Assert.AreEqual(4, array1.Capacity); array1.Get(0, @valTmp); Assert.AreEqual<InnerT>(val, valTmp); array1.Get(1, @valTmp); Assert.AreEqual<InnerT>(val, valTmp); array1.Get(2, @valTmp); Assert.AreEqual<InnerT>(val, valTmp); array1.Get(3, @valTmp); Assert.AreEqual<InnerT>(val, valTmp); array1.Clear; val1 := 44; val2 := 105; val3 := 119; array1.Add(@val1); array1.Add(@val2); array1.Add(@val3); Assert.AreEqual(3, array1.Count); Assert.AreEqual(4, array1.Capacity); SetLength(arr, 5); arr[4] := val; array1.InsertMany(1, @arr[0], 5); Assert.AreEqual(8, array1.Count); Assert.AreEqual(8, array1.Capacity); array1.Get(0, @valTmp); Assert.AreEqual<InnerT>(val1, valTmp); array1.Get(1, @valTmp); Assert.AreEqual<InnerT>(val, valTmp); array1.Get(2, @valTmp); Assert.AreEqual<InnerT>(val, valTmp); array1.Get(3, @valTmp); Assert.AreEqual<InnerT>(val, valTmp); array1.Get(4, @valTmp); Assert.AreEqual<InnerT>(val, valTmp); array1.Get(5, @valTmp); Assert.AreEqual<InnerT>(val, valTmp); array1.Get(6, @valTmp); Assert.AreEqual<InnerT>(val2, valTmp); array1.Get(7, @valTmp); Assert.AreEqual<InnerT>(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 TDynamicArraysBaseTest<TT, InnerT>.TestAddTwoDiff(AValue1, AValue2 : Integer); var v1, v2, v3, vTmp: InnerT; cmp: IComparer<InnerT>; begin Assert.AreNotEqual(AValue1, AValue2, 'AValue1 and AValue2 must be not equal in TestAddTwoDiff()!'); if IsTTUnsigned AND (AValue1 < 0) then AValue1 := -AValue1; // this is mostly for Byte and ShortInt types if IsTTUnsigned AND (AValue2 < 0) then AValue2 := -AValue2; v1 := AValue1; //CreateValue<TT>(AValue1); v2 := AValue2; //CreateValue<TT>(AValue2); array1.Add(@v1); array1.Add(@v2); array1.Get(0, @vTmp); Assert.AreEqual<InnerT>(v1, vTmp); array1.Get(1, @vTmp); Assert.AreEqual<InnerT>(v2, vTmp); array1.Get(0, @vTmp); Assert.AreEqual<InnerT>(v1, 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.AreEqual(0, array1.IndexOf(@v1)); Assert.AreEqual(1, array1.IndexOf(@v2)); Assert.AreEqual(0, array1.IndexOfFrom(@v1, 0)); Assert.AreEqual(-1, array1.IndexOfFrom(@v1, 1)); Assert.AreEqual(-1, array1.IndexOfFrom(@v1, 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@v1, 3)); Assert.AreEqual(-1, array1.IndexOfFrom(@v1, 555)); Assert.AreEqual(1, array1.IndexOfFrom(@v2, 0)); Assert.AreEqual(1, array1.IndexOfFrom(@v2, 1)); Assert.AreEqual(-1, array1.IndexOfFrom(@v2, 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@v2, 3)); Assert.AreEqual(-1, array1.IndexOfFrom(@v2, 555)); cmp := TComparer<InnerT>.Default; if (AValue1 <> 0) AND (AValue2 <> 0) then begin v3 := AValue1 + AValue2; if (cmp.Compare(v3, v1) <> 0) AND (cmp.Compare(v3, v2) <> 0) then Assert.AreEqual(-1, array1.IndexOf(@v3)); Assert.AreEqual(-1, array1.IndexOfFrom(@v3, 0)); Assert.AreEqual(-1, array1.IndexOfFrom(@v3, 1)); Assert.AreEqual(-1, array1.IndexOfFrom(@v3, 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@v3, 555)); v3 := AValue1 - AValue2; if (cmp.Compare(v3, v1) <> 0) AND (cmp.Compare(v3, v2) <> 0) then Assert.AreEqual(-1, array1.IndexOf(@v3)); Assert.AreEqual(-1, array1.IndexOfFrom(@v3, 0)); Assert.AreEqual(-1, array1.IndexOfFrom(@v3, 1)); Assert.AreEqual(-1, array1.IndexOfFrom(@v3, 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@v3, 555)); end; end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestAddTwoEqual(AValue1, AValue2: Integer); var v,vv,vvv, vTmp: InnerT; s: string absolute v; ss: string absolute vv; cmp: IComparer<InnerT>; begin Assert.AreEqual(AValue1, AValue2, 'AValue1 and AValue2 must be equal in TestAddTwoEqual()!'); if IsTTUnsigned AND (AValue1 < 0) then AValue1 := -AValue1; // this is mostly for Byte and ShortInt types if IsTTUnsigned AND (AValue2 < 0) then AValue2 := -AValue2; v := AValue1; vv := AValue2; array1.Add(@v); array1.Add(@vv); Assert.AreEqual<InnerT>(v, vv); array1.Get(1, @vTmp); Assert.AreEqual<InnerT>(v, vTmp); array1.Get(0, @vTmp); Assert.AreEqual<InnerT>(vv, vTmp); Assert.AreEqual(0, array1.IndexOf(@v)); Assert.AreEqual(0, array1.IndexOf(@vv)); array1.Get(0, @vTmp); Assert.AreEqual<InnerT>(v, vTmp); array1.Get(1, @vTmp); Assert.AreEqual<InnerT>(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.AreEqual(0, array1.IndexOfFrom(@v, 0)); Assert.AreEqual(1, array1.IndexOfFrom(@v, 1)); Assert.AreEqual(0, array1.IndexOfFrom(@vv, 0)); Assert.AreEqual(1, array1.IndexOfFrom(@vv, 1)); Assert.AreEqual(-1, array1.IndexOfFrom(@v, 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@v, 3)); Assert.AreEqual(-1, array1.IndexOfFrom(@v, 555)); Assert.AreEqual(-1, array1.IndexOfFrom(@vv, 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@vv, 3)); Assert.AreEqual(-1, array1.IndexOfFrom(@vv, 555)); cmp := TComparer<InnerT>.Default; if AValue1 <> 0 then begin vvv := AValue1 + AValue2; if (cmp.Compare(vvv, v) <> 0) AND (cmp.Compare(vvv, vv) <> 0) then begin Assert.AreEqual(-1, array1.IndexOf(@vvv)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv, 0)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv, 1)); end; Assert.AreEqual(-1, array1.IndexOfFrom(@vvv, 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv, 555)); vvv := AValue1 - AValue2; if (cmp.Compare(vvv, v) <> 0) AND (cmp.Compare(vvv, vv) <> 0) then begin Assert.AreEqual(-1, array1.IndexOf(@vvv)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv, 0)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv, 1)); end; Assert.AreEqual(-1, array1.IndexOfFrom(@vvv, 2)); Assert.AreEqual(-1, array1.IndexOfFrom(@vvv, 555)); end; end; procedure TDynamicArraysBaseTest<TT, InnerT>.TestGrow; var i: Integer; v: InnerT; begin Assert.AreEqual(0, array1.Capacity); v := 11; array1.Add(@v); Assert.AreEqual(4, array1.Capacity); v := 22; array1.Add(@v); v := 33; array1.Add(@v); Assert.AreEqual(4, array1.Capacity); v := 44; array1.Add(@v); Assert.AreEqual(8, array1.Capacity); v := 11; array1.Add(@v); v := 55; array1.Add(@v); v := 66; array1.Add(@v); v := 77; array1.Add(@v); Assert.AreEqual(12, array1.Capacity); v := 11; array1.Add(@v); Assert.AreEqual(12, array1.Capacity); Assert.AreEqual(9, array1.Count); for i := 0 to 2 do begin v := i + 11; array1.Add(@v); end; Assert.AreEqual(28, array1.Capacity); for i := 0 to 15 do begin v := i + 11; array1.Add(@v); end; Assert.AreEqual(28, array1.Count); Assert.AreEqual(44, array1.Capacity); for i := 0 to 15 do begin v := i + 11; array1.Add(@v); end; Assert.AreEqual(44, array1.Count); Assert.AreEqual(60, array1.Capacity); for i := 0 to 15 do begin v := i + 11; array1.Add(@v); end; Assert.AreEqual(60, array1.Count); Assert.AreEqual(76, array1.Capacity); for i := 0 to 15 do begin v := i + 11; array1.Add(@v); end; Assert.AreEqual(76, array1.Count); Assert.AreEqual(95, array1.Capacity); for i := 0 to 18 do begin v := i + 11; array1.Add(@v); 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; procedure TDynamicArraysBaseTest<TT, InnerT>.TestHGetToken1; var flag: Boolean; begin for flag := False to True do begin Assert.AreEqual(0, HGetTokenCount('', '', flag)); Assert.AreEqual(1, HGetTokenCount('a', '', flag)); Assert.AreEqual('a', HGetToken('a', '', flag, 0)); Assert.AreEqual(1, HGetTokenCount('abc', '', flag)); Assert.AreEqual('abc', HGetToken('abc', '', flag, 0)); Assert.AreEqual(0, HGetTokenCount('', '.', flag)); Assert.AreEqual(0, HGetTokenCount('', '..', flag)); Assert.AreEqual(0, HGetTokenCount('', 'a', flag)); Assert.AreEqual(2, HGetTokenCount('a c', ' ', flag)); Assert.AreEqual('a', HGetToken('a c', ' ', flag, 0)); Assert.AreEqual('c', HGetToken('a c', ' ', flag, 1)); Assert.AreEqual(2, HGetTokenCount('a c', ' ', flag)); Assert.AreEqual('a', HGetToken('a c', ' ', flag, 0)); Assert.AreEqual('c', HGetToken('a c', ' ', flag, 1)); Assert.AreEqual(1, HGetTokenCount(';a c;', ';', flag)); Assert.AreEqual('a c', HGetToken(';a c;', ';', flag, 0)); Assert.AreEqual(2, HGetTokenCount(';a;c;', ';;', flag)); Assert.AreEqual('a', HGetToken(';a;c;', ';;', flag, 0)); Assert.AreEqual('c', HGetToken(';a;c;', ';;', flag, 1)); Assert.AreEqual(2, HGetTokenCount('auto;moto velo foto;', ';', flag)); Assert.AreEqual('auto', HGetToken('auto;moto velo foto;', ';', flag, 0)); Assert.AreEqual('moto velo foto', HGetToken('auto;moto velo foto;', ';', flag, 1)); Assert.AreEqual(3, HGetTokenCount('auto;moto velo foto;.', ';', flag)); Assert.AreEqual('auto', HGetToken('auto;moto velo foto;.', ';', flag, 0)); Assert.AreEqual('moto velo foto', HGetToken('auto;moto velo foto;.', ';', flag, 1)); Assert.AreEqual('.', HGetToken('auto;moto velo foto;.', ';', flag, 2)); end; Assert.AreEqual(2, HGetTokenCount(';;a;;c;;', ';', False)); Assert.AreEqual('a', HGetToken(';;a;;c;;', ';', False, 0)); Assert.AreEqual('c', HGetToken(';;a;;c;;', ';', False, 1)); Assert.AreEqual(4, HGetTokenCount(';;a;;c;;', ';', True)); Assert.AreEqual('a', HGetToken(';;a;;c;;', ';', True, 0)); Assert.AreEqual('', HGetToken(';;a;;c;;', ';', True, 1)); Assert.AreEqual('c', HGetToken(';;a;;c;;', ';', True, 2)); Assert.AreEqual('', HGetToken(';;a;;c;;', ';', True, 3)); Assert.AreEqual(2, HGetTokenCount(';.a;;c..', ';.', False)); Assert.AreEqual('a', HGetToken(';.a;;c..', ';.', False, 0)); Assert.AreEqual('c', HGetToken(';.a;;c..', ';.', False, 1)); Assert.AreEqual(4, HGetTokenCount(';.a;;c..', ';.', True)); Assert.AreEqual('a', HGetToken(';.a;;c.', ';.', True, 0)); Assert.AreEqual('', HGetToken(';.a;;c..', ';.', True, 1)); Assert.AreEqual('c', HGetToken(';.a;;c..', ';.', True, 2)); Assert.AreEqual('', HGetToken(';.a;;c..', ';.', True, 3)); end; initialization Randomize; // need for testing sorting algs performance // only SIGNED types here (and FLOAT) TDUnitX.RegisterTestFixture(TDynamicArraysBaseTest<THArrayInteger, Integer>); TDUnitX.RegisterTestFixture(TDynamicArraysBaseTest<THArraySmallInt, SmallInt>); TDUnitX.RegisterTestFixture(TDynamicArraysBaseTest<THArrayInt64, Int64>); // TDUnitX.RegisterTestFixture(TDynamicArraysBaseTest<THArrayByte, Byte>); // TDUnitX.RegisterTestFixture(TDynamicArraysBaseTest<THArrayShortInt, ShortInt>); //TDUnitX.RegisterTestFixture(TDynamicArraysBaseTest<THarrayPointer, Pointer>); TDUnitX.RegisterTestFixture(TDynamicArraysBaseTest<THarraySingle, Single>); TDUnitX.RegisterTestFixture(TDynamicArraysBaseTest<THarrayDouble, Double>); TDUnitX.RegisterTestFixture(TDynamicArraysBaseTest<THarrayCurrency, Currency>); TDUnitX.RegisterTestFixture(TDynamicArraysBaseTest<THarrayExtended, Extended>); // TDUnitX.RegisterTestFixture(TDynamicArraysBaseTest<THArrayByte, Byte>); // TDUnitX.RegisterTestFixture(TDynamicArraysBaseTest<THarrayBoolean, Boolean>); end.