utils/tests/uutlEnumeratorTests.pas

unit uutlEnumeratorTests;

{$mode objfpc}{$H+}
{$IFDEF UTL_NESTED_PROCVARS}
  {$modeswitch nestedprocvars}
{$ENDIF}

interface

uses
  Classes, SysUtils, TestFramework,
  uutlEnumerator, uutlInterfaces, uutlGenerics;

type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  IIntEnumerator = specialize IutlEnumerator<Integer>;
  TutlEnumeratorTests = class(TTestCase)
  protected
    fEnumerator: IIntEnumerator;

    function  GenerateOther(const aData: array of Integer): IIntEnumerator;
    procedure Generate(const aData: array of Integer); virtual; abstract;

  published
    // Procedure Names: ProcedureUnderTest_[Parameter]_EnumeratorItems_Result
    procedure Iterate_1to5_1to5;
    {$IFDEF UTL_ENUMERATORS}
    procedure Count_1to5_5;
    procedure Any_Empty_False;
    procedure Any_1to5_True;
    procedure Reverse_1to5_5to1;
    procedure Skip2_1to5_3to5;
    procedure Take3_1to5_1to3;
    procedure Skip5_Reverse_0to9_9to5;
    procedure Take5_Reverse_0to9_4to0;
    procedure Reverse_Skip5_0to9_4to0;
    procedure Reverse_Take5_0to9_9to5;
    procedure Contains3_1to5_true;
    procedure Contains9_1to5_false;
    procedure Concat6to8_1to5_1to8;
    {$IFDEF UTL_ADVANCED_ENUMERATORS}
    procedure Sort;
    procedure Where_IsEven;
    procedure Distinct;
    procedure Intersect;
    procedure Union;
    procedure Without;
    procedure Select;
    {$ENDIF}
    {$ENDIF}
  end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  TutlArrayEnumeratorTests = class(TutlEnumeratorTests)
  protected
    procedure Generate(const aData: array of Integer); override;
  public
    procedure SetUp; override;
  end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  TutlQueueEnumeratorTests = class(TutlEnumeratorTests)
  private type
    TIntQueue = specialize TutlQueue<Integer>;
  private
    fQueue: TIntQueue;
  protected
    procedure Generate(const aData: array of Integer); override;
  public
    procedure SetUp; override;
    procedure TearDown; override;
  end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  TutlStackEnumeratorTests = class(TutlEnumeratorTests)
  private type
    TIntStack = specialize TutlStack<Integer>;
  private
    fStack: TIntStack;
  protected
    procedure Generate(const aData: array of Integer); override;
  public
    procedure SetUp; override;
    procedure TearDown; override;
  end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  TutlListEnumeratorTests = class(TutlEnumeratorTests)
  private type
    TIntList = specialize TutlSimpleList<Integer>;
  private
    fList: TIntList;
  protected
    procedure Generate(const aData: array of Integer); override;
  public
    procedure SetUp; override;
    procedure TearDown; override;
  end;

implementation

{$IF DEFINED(UTL_ENUMERATORS) AND DEFINED(UTL_ADVANCED_ENUMERATORS)}
uses
  uutlFilter, uutlComparer;
{$ENDIF}

type
  TIntArrayEnumerator = specialize TutlArrayEnumerator<Integer>;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TutlEnumeratorTests///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TutlEnumeratorTests.GenerateOther(const aData: array of Integer): IIntEnumerator;
var
  i: Integer;
  arr: TIntArrayEnumerator.TArray;
begin
  SetLength(arr, Length(aData));
  for i := low(aData) to high(aData) do
    arr[i] := aData[i];
  result := TIntArrayEnumerator.Create(arr);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlEnumeratorTests.Iterate_1to5_1to5;
begin
  Generate([1, 2, 3, 4, 5]);
  fEnumerator.Reset;
  AssertTrue  (fEnumerator.MoveNext);
  AssertEquals(1, fEnumerator.GetCurrent);
  AssertTrue  (fEnumerator.MoveNext);
  AssertEquals(2, fEnumerator.GetCurrent);
  AssertTrue  (fEnumerator.MoveNext);
  AssertEquals(3, fEnumerator.GetCurrent);
  AssertTrue  (fEnumerator.MoveNext);
  AssertEquals(4, fEnumerator.GetCurrent);
  AssertTrue  (fEnumerator.MoveNext);
  AssertEquals(5, fEnumerator.GetCurrent);
  AssertFalse (fEnumerator.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{$IFDEF UTL_ENUMERATORS}
procedure TutlEnumeratorTests.Count_1to5_5;
var
  i: Integer;
begin
  Generate([1, 2, 3, 4, 5]);
  i := fEnumerator.Count;
  AssertEquals(5, i);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlEnumeratorTests.Any_Empty_False;
begin
  AssertFalse(fEnumerator.Any);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlEnumeratorTests.Any_1to5_True;
begin
  Generate([1, 2, 3, 4, 5]);
  AssertTrue(fEnumerator.Any);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlEnumeratorTests.Reverse_1to5_5to1;
var
  e: IIntEnumerator;
begin
  e := fEnumerator.Reverse;
  Generate([1, 2, 3, 4, 5]);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(5, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(4, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(3, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(2, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(1, e.GetCurrent);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlEnumeratorTests.Skip2_1to5_3to5;
var
  e: IIntEnumerator;
begin
  e := fEnumerator.Skip(2);
  Generate([1, 2, 3, 4, 5]);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(3, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(4, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(5, e.GetCurrent);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlEnumeratorTests.Take3_1to5_1to3;
var
  e: IIntEnumerator;
begin
  e := fEnumerator.Take(3);
  Generate([1, 2, 3, 4, 5]);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(1, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(2, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(3, e.GetCurrent);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlEnumeratorTests.Skip5_Reverse_0to9_9to5;
var
  e: IIntEnumerator;
begin
  e := fEnumerator.Skip(5).Reverse;
  Generate([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(9, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(8, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(7, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(6, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(5, e.GetCurrent);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlEnumeratorTests.Take5_Reverse_0to9_4to0;
var
  e: IIntEnumerator;
begin
  e := fEnumerator.Take(5).Reverse;
  Generate([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(4, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(3, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(2, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(1, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(0, e.GetCurrent);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlEnumeratorTests.Reverse_Skip5_0to9_4to0;
var
  e: IIntEnumerator;
begin
  e := fEnumerator.Reverse.Skip(5);
  Generate([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(4, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(3, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(2, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(1, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(0, e.GetCurrent);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlEnumeratorTests.Reverse_Take5_0to9_9to5;
var
  e: IIntEnumerator;
begin
  e := fEnumerator.Reverse.Take(5);
  Generate([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(9, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(8, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(7, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(6, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(5, e.GetCurrent);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlEnumeratorTests.Contains3_1to5_true;
var
  b: Boolean;
begin
  Generate([1, 2, 3, 4, 5]);
  b := fEnumerator.Contains(3, specialize TutlEqualityComparer<Integer>.Create);
  AssertTrue(b);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlEnumeratorTests.Contains9_1to5_false;
var
  b: Boolean;
begin
  Generate([1, 2, 3, 4, 5]);
  b := fEnumerator.Contains(9, specialize TutlEqualityComparer<Integer>.Create);
  AssertFalse(b);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlEnumeratorTests.Concat6to8_1to5_1to8;
var
  e: IIntEnumerator;
begin
  e := fEnumerator.Concat(GenerateOther([6, 7, 8]));
  Generate([1, 2, 3, 4, 5]);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(1, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(2, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(3, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(4, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(5, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(6, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(7, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(8, e.GetCurrent);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{$IFDEF UTL_ADVANCED_ENUMERATORS}
procedure TutlEnumeratorTests.Sort;
var
  e: IIntEnumerator;
begin
  e := fEnumerator.Sort(specialize TutlComparer<Integer>.Create);
  Generate([5, 8, 2, 6, 9, 4, 2, 6, 8, 4, 2, 5, 8, 4]);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(2, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(2, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(2, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(4, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(4, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(4, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(5, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(5, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(6, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(6, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(8, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(8, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(8, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(9, e.GetCurrent);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function IsEven(constref i: Integer): Boolean;
begin
  result := (i mod 2) = 0;
end;

procedure TutlEnumeratorTests.Where_IsEven;
var
  e: IIntEnumerator;
begin
  e := fEnumerator.Where(specialize TutlCallbackFilter<Integer>.Create(@IsEven));
  Generate([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(0, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(2, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(4, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(6, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(8, e.GetCurrent);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlEnumeratorTests.Distinct;
var
  e: IIntEnumerator;
begin
  e := fEnumerator.Distinct(specialize TutlComparer<Integer>.Create);
  Generate([1, 5, 2, 7, 1, 3, 7, 4, 5, 8]);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(1, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(5, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(2, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(7, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(3, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(4, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(8, e.Current);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlEnumeratorTests.Intersect;
var
  e: IIntEnumerator;
begin
  e := fEnumerator
    .Intersect(GenerateOther([5, 6, 8]), specialize TutlComparer<Integer>.Create);
  Generate([1, 6, 4, 8, 2, 5]);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(6, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(8, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(5, e.Current);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlEnumeratorTests.Union;
var
  e: IIntEnumerator;
begin
  e := fEnumerator
    .Union(GenerateOther([9, 3, 4, 6, 7]), specialize TutlComparer<Integer>.Create);
  Generate([1, 6, 4, 8, 2, 5]);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(1, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(6, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(4, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(8, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(2, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(5, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(9, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(3, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(7, e.Current);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlEnumeratorTests.Without;
var
  e: IIntEnumerator;
begin
  e := fEnumerator
    .Without(GenerateOther([6, 8, 5]), specialize TutlComparer<Integer>.Create);
  Generate([1, 6, 4, 8, 2, 5]);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(1, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(4, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(2, e.Current);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function ConvertToFloat(constref a: Integer): Single;
begin
  result := Single(a) / 2.0;
end;

procedure TutlEnumeratorTests.Select;
var
  e: specialize IutlEnumerator<Single>;
begin
  e := specialize TutlSelectEnumerator<Integer, Single>.Create(
    fEnumerator,
    specialize TutlCallbackSelector<Integer, Single>.Create(@ConvertToFloat));
  Generate([1, 2, 3, 4, 5]);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(0.5, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(1.0, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(1.5, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(2.0, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(2.5, e.Current);
  AssertFalse (e.MoveNext);
end;
{$ENDIF}
{$ENDIF}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TutlArrayEnumeratorTests//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlArrayEnumeratorTests.Generate(const aData: array of Integer);
var
  i: Integer;
  arr: TIntArrayEnumerator.TArray;
begin
  SetLength(arr, Length(aData));
  for i := low(aData) to high(aData) do
    arr[i] := aData[i];
  (fEnumerator as TIntArrayEnumerator).Data := arr;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlArrayEnumeratorTests.SetUp;
begin
  fEnumerator := TIntArrayEnumerator.Create;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TutlQueueEnumeratorTests//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlQueueEnumeratorTests.Generate(const aData: array of Integer);
var
  i: Integer;
begin
  fQueue.Clear;
  for i in aData do
    fQueue.Enqueue(i);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlQueueEnumeratorTests.SetUp;
begin
  inherited SetUp;
  fQueue := TIntQueue.Create(true);
  fEnumerator := fQueue.GetUtlEnumerator;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlQueueEnumeratorTests.TearDown;
begin
  FreeAndNil(fQueue);
  fEnumerator := nil;
  inherited TearDown;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TutlStackEnumeratorTests//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlStackEnumeratorTests.Generate(const aData: array of Integer);
var
  i: Integer;
begin
  fStack.Clear;
  for i in aData do
    fStack.Push(i);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlStackEnumeratorTests.SetUp;
begin
  inherited SetUp;
  fStack := TIntStack.Create(true);
  fEnumerator := fStack.GetUtlEnumerator;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlStackEnumeratorTests.TearDown;
begin
  fEnumerator := nil;
  FreeAndNil(fStack);
  inherited TearDown;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TutlListEnumeratorTests///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlListEnumeratorTests.Generate(const aData: array of Integer);
var
  i: Integer;
begin
  fList.Clear;
  for i in aData do
    fList.Add(i);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlListEnumeratorTests.SetUp;
begin
  inherited SetUp;
  fList := TIntList.Create(true);
  fEnumerator := fList.GetUtlEnumerator;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlListEnumeratorTests.TearDown;
begin
  fEnumerator := nil;
  FreeAndNil(fList);
  inherited TearDown;
end;

initialization
  RegisterTest(TutlArrayEnumeratorTests.Suite);
  RegisterTest(TutlQueueEnumeratorTests.Suite);
  RegisterTest(TutlStackEnumeratorTests.Suite);
  RegisterTest(TutlListEnumeratorTests.Suite);

end.