utils/tests/uutlQueueTests.pas

unit uutlQueueTests;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, TestFramework, contnrs, uTestHelper,
  uutlGenerics;

type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  TIntQueue  = specialize TutlQueue<Integer>;
  TIntfQueue = specialize TutlQueue<IUnknown>;
  TObjQueue  = specialize TutlQueue<TObject>;
  TutlQueueTests = class(TIntfObjOwner)
  private
    fIntQueue: TIntQueue;
    fIntfQueue: TIntfQueue;
    fObjQueue: TObjQueue;

  protected
    procedure SetUp; override;
    procedure TearDown; override;

  published
    procedure Prop_Count;
    procedure Prop_Empty;
    procedure Meth_Peek;
    procedure Meth_EnqueueDequeue1000Times;
    procedure Meth_EnqueueDequeue1000Items;
    procedure Meth_EnqueueDequeue1000Items1000Times;
    procedure Meth_EnqueueDequeue100Interfaces;
    procedure Meth_EnqueueDequeue100_ObjectOwned_WithFree;
    procedure Meth_EnqueueDequeue100_ObjectOwned_WithoutFree;
    procedure Meth_EnqueueDequeue100_ObjectNotOwned_WithFree;
    procedure Meth_EnqueueDequeue100_ObjectNotOwned_WithoutFree;
    procedure Enumerate;
    procedure Dtor_FreesAllItems;
  end;

implementation

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TutlQueueTests////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlQueueTests.SetUp;
begin
  inherited SetUp;
  fIntQueue  := TIntQueue.Create(true);
  fIntfQueue := TIntfQueue.Create(true);
  fObjQueue  := TObjQueue.Create(true);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlQueueTests.TearDown;
begin
  FreeAndNil(fIntQueue);
  FreeAndNil(fIntfQueue);
  FreeAndNil(fObjQueue);
  inherited TearDown;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlQueueTests.Prop_Count;
begin
  AssertEquals(0, fIntQueue.Count);
  fIntQueue.Enqueue(123);
  AssertEquals(1, fIntQueue.Count);
  fIntQueue.Enqueue(234);
  AssertEquals(2, fIntQueue.Count);
  fIntQueue.Enqueue(345);
  AssertEquals(3, fIntQueue.Count);
  fIntQueue.Dequeue;
  AssertEquals(2, fIntQueue.Count);
  fIntQueue.Dequeue;
  AssertEquals(1, fIntQueue.Count);
  fIntQueue.Dequeue;
  AssertEquals(0, fIntQueue.Count);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlQueueTests.Prop_Empty;
begin
  AssertEquals(true, fIntQueue.IsEmpty);
  fIntQueue.Enqueue(345);
  AssertEquals(false, fIntQueue.IsEmpty);
  fIntQueue.Dequeue;
  AssertEquals(true, fIntQueue.IsEmpty);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlQueueTests.Meth_Peek;
begin
  fIntQueue.Enqueue(123);
  AssertEquals(123, fIntQueue.Peek);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlQueueTests.Meth_EnqueueDequeue1000Times;
var
  i, tmp: Integer;
begin
  for i := 0 to 1000 do begin
    fIntQueue.Enqueue(i);
    tmp := fIntQueue.Dequeue;
    AssertEquals(i, tmp);
  end;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlQueueTests.Meth_EnqueueDequeue1000Items;
var
  i, tmp: Integer;
begin
  for i := 0 to 1000 do
    fIntQueue.Enqueue(i);
  for i := 0 to 1000 do begin
    tmp := fIntQueue.Dequeue;
    AssertEquals(i, tmp);
  end;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlQueueTests.Meth_EnqueueDequeue1000Items1000Times;
var
  i, j, tmp: Integer;
begin
  for j := 0 to 1000 do begin
    for i := 0 to 1000 do
      fIntQueue.Enqueue(i);
    for i := 0 to 1000 do begin
      tmp := fIntQueue.Dequeue;
      AssertEquals(i, tmp);
    end;
  end;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlQueueTests.Meth_EnqueueDequeue100Interfaces;
var
  i: Integer;
begin
  for i := 0 to 100 do begin
    fIntfQueue.Enqueue(TIntfObj.Create(self));
    AssertEquals(i+1, IntfObjCounter);
  end;
  for i := 0 to 100 do begin
    fIntfQueue.Dequeue;
    AssertEquals(100 - i, IntfObjCounter);
  end;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlQueueTests.Meth_EnqueueDequeue100_ObjectOwned_WithFree;
var
  i: Integer;
begin
  for i := 0 to 100 do begin
    fObjQueue.Enqueue(TIntfObj.Create(self));
    AssertEquals(i+1, IntfObjCounter);
  end;
  for i := 0 to 100 do begin
    AssertNull('dequeue returned non-zero item', fObjQueue.Dequeue(true));
    AssertEquals(100 - i, IntfObjCounter);
  end;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlQueueTests.Meth_EnqueueDequeue100_ObjectOwned_WithoutFree;
var
  i: Integer;
  lst: TObjectList;
  obj: TObject;
begin
  for i := 0 to 100 do begin
    fObjQueue.Enqueue(TIntfObj.Create(self));
    AssertEquals(i+1, IntfObjCounter);
  end;
  for i := 0 to 100 do begin
    fObjQueue.Dequeue(true);
    AssertEquals(100 - i, IntfObjCounter);
  end;

  // free on dequeue
  for i := 0 to 100 do begin
    fObjQueue.Enqueue(TIntfObj.Create(self));
    AssertEquals(i+1, IntfObjCounter);
  end;
  lst := TObjectList.Create(true);
  try
    for i := 0 to 100 do begin
      obj := fObjQueue.Dequeue(false);
      AssertNotNull('dequeue returned zero item', obj);
      lst.Add(obj);
      AssertEquals(101, IntfObjCounter);
    end;
  finally
    FreeAndNil(lst);
  end;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlQueueTests.Meth_EnqueueDequeue100_ObjectNotOwned_WithFree;
var
  lst: TObjectList;
  obj: TObject;
  i: Integer;
begin
  lst := TObjectList.Create(true);
  try
    for i := 0 to 100 do begin
      obj := TIntfObj.Create(self);
      lst.Add(obj);
      fObjQueue.Enqueue(obj);
      AssertEquals(i+1, IntfObjCounter);
    end;
    fObjQueue.OwnsItems := false;
    for i := 0 to 100 do begin
      AssertNull('dequeue returned non-zero item', fObjQueue.Dequeue(true));
      AssertEquals(101, IntfObjCounter);
    end;
  finally
    FreeAndNil(lst);
  end;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlQueueTests.Meth_EnqueueDequeue100_ObjectNotOwned_WithoutFree;
var
  lst: TObjectList;
  obj: TObject;
  i: Integer;
begin
  lst := TObjectList.Create(true);
  try
    for i := 0 to 100 do begin
      obj := TIntfObj.Create(self);
      lst.Add(obj);
      fObjQueue.Enqueue(obj);
      AssertEquals(i+1, IntfObjCounter);
    end;
    fObjQueue.OwnsItems := false;
    for i := 0 to 100 do begin
      AssertNotNull('dequeue returned zero item', fObjQueue.Dequeue(false));
      AssertEquals(101, IntfObjCounter);
    end;
  finally
    FreeAndNil(lst);
  end;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlQueueTests.Enumerate;
var
  e: TIntQueue.IutlEnumerator;
begin
  e := fIntQueue.GetUtlEnumerator;
  fIntQueue.Enqueue(1);
  fIntQueue.Enqueue(2);
  fIntQueue.Enqueue(3);
  fIntQueue.Enqueue(4);
  fIntQueue.Enqueue(5);
  fIntQueue.Dequeue;
  fIntQueue.Dequeue;
  fIntQueue[1] := 9;
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(3, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(9, e.GetCurrent);
  AssertTrue  (e.MoveNext);
  AssertEquals(5, e.GetCurrent);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlQueueTests.Dtor_FreesAllItems;
begin
  fObjQueue.Enqueue(TIntfObj.Create(self));
  FreeAndNil(fObjQueue);
  AssertEquals(0, IntfObjCounter);
end;

initialization
  RegisterTest(TutlQueueTests.Suite);

end.