dynamicarrays/prj/Delphi/DynamicArraysOTests/DynamicArraysShortIntTest.pas - master - lasersquad/DynamicArrays

dynamicarrays/prj/Delphi/DynamicArraysOTests/DynamicArraysShortIntTest.pas
445 строк11 KB
lasersquad0
new files
20 май 2026, 22:15
20 май 2026, 22:15b70be5f
unit DynamicArraysShortIntTest;

interface

uses
  DUnitX.TestFramework, {TestBase,} DynamicArrays, DynamicArraysBaseTest;

type
  [TestFixture]
  TDynamicArraysShortIntTest<TT: constructor, THArray; InnerT: record> = class(TDynamicArraysBaseTest<TT, InnerT>)
  public
    [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; override;
    [Test]
    procedure TestEmpty2; override;
    [Test]
    procedure TestCountOne; override;
    [Test]
    procedure TestUpdate; override;
    [Test]
    procedure TestUpdateMany; override;
    [Test]
    procedure TestZero; override;
    [Test]
    procedure TestSwap; override;
    [Test]
    procedure TestAddFillValues1; override;
    [Test]
    procedure TestAddFillValues2; override;
    [Test]
    procedure TestIndexOF1; override;
    [Test]
    [TestCase('TestIndexofA','4, 1, 2, 0')] // last figure is used for assers when TT=Boolean
    [TestCase('TestIndexofB','0, 1, 3, 0')]
    [TestCase('TestIndexofC','2, 5, 1, 1')]
    [TestCase('TestIndexofD','-14, 13, -1, 0')]
    [TestCase('TestIndexofE','-127, -13, -1, 0')]
    [TestCase('TestIndexofF','0, 13, 127, 0')]
    [TestCase('TestIndexofG','1, 2, 127, 0')]
    [TestCase('TestIndexofH','2, 0, -1, 0')]
    procedure TestIndexOf2(AValue1, AValue2, AValue3, AValue4: Integer); override;
    [Test]
    procedure TestCapacity1; override;
    [Test]
    procedure TestCapacity2; override;
    [Test]
    [TestCase('TestA','5,1')]
    [TestCase('TestB','4,3')]
    [TestCase('TestC','0,-1')]
    [TestCase('TestD','-52, -51')]
    [TestCase('TestE','61, 59')]
    [TestCase('TestF','-1, 0')]
    [TestCase('TestG','-6, 5')]
    [TestCase('TestH','8, -7')]
    [TestCase('TestI','3,-1')]
    procedure TestAddTwoDiff(AValue1, AValue2 : Integer); override;
    [Test]
    [TestCase('TestA','011,   011')]
    [TestCase('TestB','  59, 59')]
    [TestCase('TestC','  0, 0')]
    [TestCase('TestD','  -59,-59')]
    [TestCase('TestF','  -1, -1')]
    [TestCase('TestG','00000000, 0000000')]
    procedure TestAddTwoEqual(AValue1, AValue2 : Integer); override;
    [Test]
    procedure TestGrow; override;
    [Test]
    procedure TestInsert1; override;
    [Test]
    procedure TestInsert2; override;
    [Test]
    procedure TestDeleteValue1; override;
    [Test]
    procedure TestDeleteValue2; override;
    [Test]
    procedure TestAddClearAdd1; override;
    [Test]
    procedure TestAddClearAdd2; override;
    [Test]
    procedure TestSort1; overload; override;

    // <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;119;9, 1;9;12;44;53;100;119')]
    [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')]
    [TestCase('TestL', '-1;-2;-3;-4;-5, -5;-4;-3;-2;-1')]
    [TestCase('TestM', '-5;-4;-3;-2;-1, -5;-4;-3;-2;-1')]
    [TestCase('TestN', '44;53;-1;12;100;-119;9, -249,-1;9;12;44;53;100')]
    [TestCase('TestO', '44;-44;-44;44;44;44;9, ;-44;-44;9;44;44;44;44')]
    [TestCase('TestP', '9;-1;9;-1;9;-1;9;1, -1;-1;-1;1;;9;9;9;9;;')]
    procedure TestSort2(AValue1, AValue2: string); overload;  override;

    [Test]
    procedure TestAddMany; override;
    [Test]
    procedure TestInsertMany; override;

    {
    procedure TestBubbleSortPerformance; override;
    procedure TestSelectionSortPerformance; override;
    procedure TestQuickSortPerformance; override;
    procedure TestInsertSortPerformance; override;
    procedure TestShakerSortPerformance; override;
    }
    [Test]
    [Ignore('Ignore this test to save testing time')]
    procedure TestAllSortAlgsPerformance; override;  // 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, 255, -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, -1')]
    [TestCase('TestM', '16;15, 16, 1')]
    //[Ignore('temporary IMGORE')]
    [Category('QuickFindTests')]
    procedure TestQuickFind(AValue1, AValue2, AValue3: string); override;

end;

const
  ARRAYSIZE_FOR_SORTING = 20_000;

implementation

uses System.TypInfo, System.Generics.Defaults, SysUtils, Winapi.Windows;


procedure TDynamicArraysShortIntTest<TT, InnerT>.TearDownFixture;
begin
  //FreeTObjects;
end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.Setup;
begin
  array1 := TTestingArrayType.Create;
  array2 := TTestingArrayType.Create;
end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.TearDown;
begin
  FreeAndNil(array1);
  FreeAndNil(array2);
end;



procedure TDynamicArraysShortIntTest<TT, InnerT>.TestAddClearAdd1;
begin
  inherited;

end;

// special implementation for UInt because base implementation works with negative figures.
procedure TDynamicArraysShortIntTest<TT, InnerT>.TestAddClearAdd2;
var
  I: Integer;
  v, v2: InnerT;
begin
  for I := 9 downto 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 downto 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 := 19 - I;
    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 TDynamicArraysShortIntTest<TT, InnerT>.TestAddFillValues1;
begin
  inherited;

end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.TestAddFillValues2;
begin
  inherited;

end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.TestAddMany;
begin
  inherited;

end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.TestAddTwoDiff(AValue1, AValue2: Integer);
begin
  inherited;

end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.TestAddTwoEqual(AValue1, AValue2: Integer);
begin
  inherited;

end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.TestAllSortAlgsPerformance;
begin
  inherited;
end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.TestCapacity1;
begin
  inherited;

end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.TestCapacity2;
begin
  inherited;

end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.TestCountOne;
begin
  inherited;

end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.TestDeleteValue1;
begin
  inherited;

end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.TestDeleteValue2;
begin
  inherited;

end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.TestEmpty1;
begin
  inherited;

end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.TestEmpty2;
begin
  inherited;

end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.TestGrow;
begin
  inherited;

end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.TestIndexOF1;
begin
  inherited;

end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.TestIndexOf2(AValue1, AValue2, AValue3, AValue4: Integer);
begin
  inherited;

end;

// special implementation for ShortInt
procedure TDynamicArraysShortIntTest<TT, InnerT>.TestInsert1;
var
  I: Integer;
  val, val2: InnerT;
begin
  for I := 0 to 99 do begin
    val := i + 20;
    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 := 120 - I - 1;
    Assert.AreEqual<InnerT>(val2, val);
  end
end;
procedure TDynamicArraysShortIntTest<TT, InnerT>.TestInsert2;
begin
  inherited;

end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.TestInsertMany;
begin
  inherited;

end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.TestQuickFind(AValue1, AValue2, AValue3: string);
begin
  inherited;

end;

{
procedure TDynamicArraysShortIntTest<TT, InnerT>.TestBubbleSortPerformance;
begin
  inherited;

end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.TestQuickSortPerformance;
begin
  inherited;

end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.TestSelectionSortPerformance;
begin
  inherited;

end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.TestShakerSortPerformance;
begin
  inherited;

end;
}
procedure TDynamicArraysShortIntTest<TT, InnerT>.TestSort1;
begin
  inherited;

end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.TestSort2(AValue1, AValue2: string);
begin
  inherited;

end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.TestSwap;
begin
  inherited;

end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.TestUpdate;
begin
  inherited;

end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.TestUpdateMany;
begin
  inherited;

end;

procedure TDynamicArraysShortIntTest<TT, InnerT>.TestZero;
begin
  inherited;

end;


initialization
   // only ONE BYTE types here
   TDUnitX.RegisterTestFixture(TDynamicArraysShortIntTest<THArrayByte, Byte>);
   TDUnitX.RegisterTestFixture(TDynamicArraysShortIntTest<THArrayShortInt, ShortInt>);

 //  TDUnitX.RegisterTestFixture(TDynamicArraysShortIntTest<THarrayBoolean, Boolean>);

end.