utils/tests/uutlLinqTests.pas

unit uutlLinqTests;

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

interface

{$IFDEF UTL_ENUMERATORS}
uses
  Classes, SysUtils, TestFramework,
  uutlLinq;

type
  TutlLinqTests = class(TTestCase)
  published
    procedure proc_Count;
    procedure proc_Any;
    procedure proc_Contains;
    procedure proc_Contains_WithComparer;
    procedure proc_ToArray;

    procedure proc_Reverse;
    procedure proc_Skip;
    procedure proc_Take;
    procedure proc_Concat;
    procedure proc_Concat_WithArray;
    {$IFDEF UTL_ADVANCED_ENUMERATORS}
    procedure proc_Sort;
    procedure proc_Sort_WithComparer;
    procedure proc_Where_WithFilter;
    procedure proc_Where_WithNormalCallback;
    procedure proc_Where_WithObjectCallback;
    {$IFDEF UTL_NESTED_PROCVARS}
    procedure proc_Where_WithNestedCallback;
    {$ENDIF}
    procedure proc_Distinct;
    procedure proc_Distinct_WithComparer;
    procedure proc_Intersect;
    procedure proc_Intersect_WithComparer;
    procedure proc_Union;
    procedure proc_Union_WithComparer;
    procedure proc_Without;
    procedure proc_Without_WithComparer;
    procedure proc_Select_WithSelector;
    procedure proc_Select_WithNormalCallback;
    procedure proc_Select_WithObjectCallback;
    {$IFDEF UTL_NESTED_PROCVARS}
    procedure proc_Select_WithNestedCallback;
    {$ENDIF}
    procedure proc_SelectMany_WithSelector;
    procedure proc_SelectMany_WithNormalCallback;
    procedure proc_SelectMany_WithObjectCallback;
    {$IFDEF UTL_NESTED_PROCVARS}
    procedure proc_SelectMany_WithNestedCallback;
    {$ENDIF}
    procedure proc_Zip;
    {$ENDIF}
  end;
{$ENDIF}

implementation

{$IFDEF UTL_ENUMERATORS}
uses
  uutlEnumerator, uutlComparer, uutlFilter, uutlTypes, uutlInterfaces;

type
  TIntArrEnumerator = specialize TutlArrayEnumerator<Integer>;
  TStringArrEnumerator = specialize TutlArrayEnumerator<String>;

  TCallbackObject = class(TInterfacedObject,
    specialize IutlFilter<Integer>,
    specialize IutlSelector<Integer, Single>)
  public
    function Filter(constref i: Integer): Boolean;
    function Select(constref i: Integer): Single;
  end;

  TSelectManyObject = class(TInterfacedObject,
    specialize IutlSelector<Integer, specialize IutlEnumerator<Single>>)
  public
    function Select(constref i: Integer): specialize IutlEnumerator<Single>;
  end;

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

function TestSelector(constref i: Integer): Single;
begin
  result := i / 2.0;
end;

function TestManySelector(constref i: Integer): specialize IutlEnumerator<Single>;
var
  data: array of Single;
begin
  SetLength(data, 3);
  data[0] := 10 * i + 1.5;
  data[1] := 10 * i + 5.0;
  data[2] := 10 * i + 7.5;
  result := specialize TutlArrayEnumerator<Single>.Create(data);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TCallbackObject.Filter(constref i: Integer): Boolean;
begin
  result := TestFilter(i);
end;

function TCallbackObject.Select(constref i: Integer): Single;
begin
  result := TestSelector(i);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TSelectManyObject.Select(constref i: Integer): specialize IutlEnumerator<Single>;
begin
  result := TestManySelector(i);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function CreateArrayEnumerator(const aSize: Integer; const aStartIndex: Integer = 1): TIntArrEnumerator.IutlEnumerator;
var
  arr: array of Integer;
  i: Integer;
begin
  SetLength(arr, aSize);
  for i := low(arr) to high(arr) do
    arr[i] := aStartIndex + i;
  result := TIntArrEnumerator.Create(arr);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function CreateArrayEnumerator(const aData: array of Integer): TIntArrEnumerator.IutlEnumerator;
var
  arr: array of Integer;
  i: Integer;
begin
  SetLength(arr, Length(aData));
  for i := low(arr) to high(arr) do
    arr[i] := aData[i];
  result := TIntArrEnumerator.Create(arr);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function CreateStringEnumerator(const aData: array of String): TStringArrEnumerator.IutlEnumerator;
var
  arr: array of String;
  i: Integer;
begin
  SetLength(arr, Length(aData));
  for i := low(arr) to high(arr) do
    arr[i] := aData[i];
  result := TStringArrEnumerator.Create(arr);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TutlLinqTests/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Count;
var
  e: TIntArrEnumerator.IutlEnumerator;
begin
  e := CreateArrayEnumerator(10);
  AssertEquals(10, specialize utlCount<Integer>(e));
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Any;
begin
  AssertFalse(specialize utlAny<Integer>(CreateArrayEnumerator(0)));
  AssertTrue (specialize utlAny<Integer>(CreateArrayEnumerator(1)));
  AssertTrue (specialize utlAny<Integer>(CreateArrayEnumerator(2)));
  AssertTrue (specialize utlAny<Integer>(CreateArrayEnumerator(9)));
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Contains;
begin
  AssertFalse(specialize utlContains<Integer>(CreateArrayEnumerator(10), 11));
  AssertFalse(specialize utlContains<Integer>(CreateArrayEnumerator(10), -1));
  AssertTrue (specialize utlContains<Integer>(CreateArrayEnumerator(10),  4));
  AssertTrue (specialize utlContains<Integer>(CreateArrayEnumerator(10),  6));
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Contains_WithComparer;
begin
  AssertFalse(specialize utlContains<Integer>(CreateArrayEnumerator(10), 11, specialize TutlEqualityComparer<Integer>.Create));
  AssertFalse(specialize utlContains<Integer>(CreateArrayEnumerator(10), -1, specialize TutlEqualityComparer<Integer>.Create));
  AssertTrue (specialize utlContains<Integer>(CreateArrayEnumerator(10),  4, specialize TutlEqualityComparer<Integer>.Create));
  AssertTrue (specialize utlContains<Integer>(CreateArrayEnumerator(10),  6, specialize TutlEqualityComparer<Integer>.Create));
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_ToArray;
var
  arr: array of Integer;
begin
  arr := specialize utlToArray<Integer>(CreateArrayEnumerator(5));
  AssertEquals(5, Length(arr));
  AssertEquals(1, arr[0]);
  AssertEquals(2, arr[1]);
  AssertEquals(3, arr[2]);
  AssertEquals(4, arr[3]);
  AssertEquals(5, arr[4]);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Reverse;
var
  e: TIntArrEnumerator.IutlEnumerator;
begin
  e := specialize utlReverse<Integer>(CreateArrayEnumerator(5));
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(5, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(4, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(3, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(2, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(1, e.Current);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Skip;
var
  e: TIntArrEnumerator.IutlEnumerator;
begin
  e := specialize utlSkip<Integer>(CreateArrayEnumerator(5), 2);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(3, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(4, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(5, e.Current);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Take;
var
  e: TIntArrEnumerator.IutlEnumerator;
begin
  e := specialize utlTake<Integer>(CreateArrayEnumerator(5), 3);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(1, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(2, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(3, e.Current);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Concat;
var
  e: TIntArrEnumerator.IutlEnumerator;
begin
  e := specialize utlConcat<Integer>(
    CreateArrayEnumerator(2, 1),
    CreateArrayEnumerator(2, 3));
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(1, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(2, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(3, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(4, e.Current);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Concat_WithArray;
var
  e: TIntArrEnumerator.IutlEnumerator;
begin
  e := specialize utlConcat<Integer>(
    specialize TutlArray<specialize IutlEnumerator<Integer>>.Create(
      CreateArrayEnumerator(2, 1),
      CreateArrayEnumerator(2, 3),
      CreateArrayEnumerator(2, 5)));
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(1, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(2, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(3, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(4, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(5, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(6, e.Current);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{$IFDEF UTL_ADVANCED_ENUMERATORS}
procedure TutlLinqTests.proc_Sort;
var
  e: TIntArrEnumerator.IutlEnumerator;
begin
  e := specialize utlSort<Integer>(CreateArrayEnumerator([1, 5, 3, 6, 7, 9, 2]));
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(1, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(2, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(3, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(5, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(6, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(7, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(9, e.Current);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Sort_WithComparer;
var
  e: TIntArrEnumerator.IutlEnumerator;
begin
  e := specialize utlSort<Integer>(CreateArrayEnumerator([1, 5, 3, 6, 7, 9, 2]), specialize TutlComparer<Integer>.Create);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(1, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(2, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(3, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(5, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(6, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(7, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(9, e.Current);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Where_WithFilter;
var
  e: TIntArrEnumerator.IutlEnumerator;
begin
  e := specialize utlWhere<Integer>(CreateArrayEnumerator(5), TCallbackObject.Create);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(2, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(4, e.Current);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Where_WithNormalCallback;
var
  e: TIntArrEnumerator.IutlEnumerator;
begin
  e := specialize utlWhere<Integer>(CreateArrayEnumerator(5), @TestFilter);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(2, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(4, e.Current);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Where_WithObjectCallback;
var
  e: TIntArrEnumerator.IutlEnumerator;
  o: TCallbackObject;
begin
  o := TCallbackObject.Create;
  try
    e := specialize utlWhere<Integer>(CreateArrayEnumerator(5), @o.Filter);
    e.Reset;
    AssertTrue  (e.MoveNext);
    AssertEquals(2, e.Current);
    AssertTrue  (e.MoveNext);
    AssertEquals(4, e.Current);
    AssertFalse (e.MoveNext);
  finally
    FreeAndNil(o);
  end;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{$IFDEF UTL_NESTED_PROCVARS}
procedure TutlLinqTests.proc_Where_WithNestedCallback;

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

var
  e: TIntArrEnumerator.IutlEnumerator;
begin
  e := specialize utlWhere<Integer>(CreateArrayEnumerator(5), @IsEventNested);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(2, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(4, e.Current);
  AssertFalse (e.MoveNext);
end;
{$ENDIF}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Distinct;
var
  e: TIntArrEnumerator.IutlEnumerator;
begin
  e := specialize utlDistinct<Integer>(CreateArrayEnumerator([1, 4, 3, 6, 1, 3, 4, 7 ]));
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(1, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(4, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(3, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(6, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(7, e.Current);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Distinct_WithComparer;
var
  e: TIntArrEnumerator.IutlEnumerator;
begin
  e := specialize utlDistinct<Integer>(CreateArrayEnumerator([1, 4, 3, 6, 1, 3, 4, 7 ]), specialize TutlComparer<Integer>.Create);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(1, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(4, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(3, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(6, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(7, e.Current);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Intersect;
var
  e: TIntArrEnumerator.IutlEnumerator;
begin
  e := specialize utlIntersect<Integer>(
    CreateArrayEnumerator([ 1, 2, 3, 4, 5, 6, 7 ]),
    CreateArrayEnumerator([ 3, 5, 4, 3 ]));
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(3, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(4, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(5, e.Current);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Intersect_WithComparer;
var
  e: TIntArrEnumerator.IutlEnumerator;
begin
  e := specialize utlIntersect<Integer>(
    CreateArrayEnumerator([ 1, 2, 3, 4, 5, 6, 7 ]),
    CreateArrayEnumerator([ 3, 5, 4, 3 ]),
    specialize TutlComparer<Integer>.Create);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(3, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(4, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(5, e.Current);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Union;
var
  e: TIntArrEnumerator.IutlEnumerator;
begin
  e := specialize utlUnion<Integer>(
    CreateArrayEnumerator([ 2, 4, 5, 7 ]),
    CreateArrayEnumerator([ 3, 5, 4, 3, 8 ]));
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(2, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(4, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(5, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(7, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(3, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(8, e.Current);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Union_WithComparer;
var
  e: TIntArrEnumerator.IutlEnumerator;
begin
  e := specialize utlUnion<Integer>(
    CreateArrayEnumerator([ 2, 4, 5, 7 ]),
    CreateArrayEnumerator([ 3, 5, 4, 3, 8 ]),
    specialize TutlComparer<Integer>.Create);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(2, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(4, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(5, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(7, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(3, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(8, e.Current);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Without;
var
  e: TIntArrEnumerator.IutlEnumerator;
begin
  e := specialize utlWithout<Integer>(
    CreateArrayEnumerator([ 1, 2, 3, 4, 5, 6, 7 ]),
    CreateArrayEnumerator([ 3, 5, 4, 3 ]),
    specialize TutlComparer<Integer>.Create);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(1, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(2, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(6, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(7, e.Current);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Without_WithComparer;
var
  e: TIntArrEnumerator.IutlEnumerator;
begin
  e := specialize utlWithout<Integer>(
    CreateArrayEnumerator([ 1, 2, 3, 4, 5, 6, 7 ]),
    CreateArrayEnumerator([ 3, 5, 4, 3 ]));
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(1, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(2, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(6, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(7, e.Current);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Select_WithSelector;
var
  e: specialize IutlEnumerator<Single>;
begin
  e := specialize utlSelect<Integer, Single>(
    CreateArrayEnumerator(4),
    TCallbackObject.Create);
  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);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Select_WithNormalCallback;
var
  e: specialize IutlEnumerator<Single>;
begin
  e := specialize utlSelect<Integer, Single>(
    CreateArrayEnumerator(4),
    @TestSelector);
  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);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Select_WithObjectCallback;
var
  o: TCallbackObject;
  e: specialize IutlEnumerator<Single>;
begin
  o := TCallbackObject.Create;
  try
    e := specialize utlSelect<Integer, Single>(
      CreateArrayEnumerator(4),
      @o.Select);
    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);
    AssertFalse (e.MoveNext);
  finally
    FreeAndNil(o);
  end;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{$IFDEF UTL_NESTED_PROCVARS}
procedure TutlLinqTests.proc_Select_WithNestedCallback;

  function TestSelectorNested(constref i: Integer): Single;
  begin
    result := i / 2.0;
  end;

var
  e: specialize IutlEnumerator<Single>;
begin
  e := specialize utlSelect<Integer, Single>(
    CreateArrayEnumerator(4),
    @TestSelectorNested);
  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);
  AssertFalse (e.MoveNext);
end;
{$ENDIF}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_SelectMany_WithSelector;
var
  e: specialize IutlEnumerator<Single>;
begin
  e := specialize utlSelectMany<Integer, Single>(
    CreateArrayEnumerator(3),
    TSelectManyObject.Create);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(11.5, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(15.0, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(17.5, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(21.5, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(25.0, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(27.5, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(31.5, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(35.0, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(37.5, e.Current);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_SelectMany_WithNormalCallback;
var
  e: specialize IutlEnumerator<Single>;
begin
  e := specialize utlSelectMany<Integer, Single>(
    CreateArrayEnumerator(3),
    @TestManySelector);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(11.5, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(15.0, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(17.5, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(21.5, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(25.0, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(27.5, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(31.5, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(35.0, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(37.5, e.Current);
  AssertFalse (e.MoveNext);
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_SelectMany_WithObjectCallback;
var
  o: TSelectManyObject;
  e: specialize IutlEnumerator<Single>;
begin
  o := TSelectManyObject.Create;
  try
    e := specialize utlSelectMany<Integer, Single>(
      CreateArrayEnumerator(3),
      @o.Select);
    e.Reset;
    AssertTrue  (e.MoveNext);
    AssertEquals(11.5, e.Current);
    AssertTrue  (e.MoveNext);
    AssertEquals(15.0, e.Current);
    AssertTrue  (e.MoveNext);
    AssertEquals(17.5, e.Current);
    AssertTrue  (e.MoveNext);
    AssertEquals(21.5, e.Current);
    AssertTrue  (e.MoveNext);
    AssertEquals(25.0, e.Current);
    AssertTrue  (e.MoveNext);
    AssertEquals(27.5, e.Current);
    AssertTrue  (e.MoveNext);
    AssertEquals(31.5, e.Current);
    AssertTrue  (e.MoveNext);
    AssertEquals(35.0, e.Current);
    AssertTrue  (e.MoveNext);
    AssertEquals(37.5, e.Current);
    AssertFalse (e.MoveNext);
  finally
    FreeAndNil(o);
  end;
end;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{$IFDEF UTL_NESTED_PROCVARS}
procedure TutlLinqTests.proc_SelectMany_WithNestedCallback;

  function TestManySelectorNested(constref i: Integer): specialize IutlEnumerator<Single>;
  begin
    result := TestManySelector(i);
  end;

var
  e: specialize IutlEnumerator<Single>;
begin
  e := specialize utlSelectMany<Integer, Single>(
    CreateArrayEnumerator(3),
    @TestManySelectorNested);
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(11.5, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(15.0, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(17.5, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(21.5, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(25.0, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(27.5, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(31.5, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(35.0, e.Current);
  AssertTrue  (e.MoveNext);
  AssertEquals(37.5, e.Current);
  AssertFalse (e.MoveNext);
end;
{$ENDIF}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure TutlLinqTests.proc_Zip;
var
  e: specialize IutlEnumerator<specialize TutlPair<Integer, String>>;
begin
  e := specialize utlZip<Integer, String>(
    CreateArrayEnumerator([ 1, 4, 6, 9 ]),
    CreateStringEnumerator([ 'fuu', 'bar', 'baz' ]));
  e.Reset;
  AssertTrue  (e.MoveNext);
  AssertEquals(1,     e.Current.First);
  AssertEquals('fuu', e.Current.Second);
  AssertTrue  (e.MoveNext);
  AssertEquals(4,     e.Current.First);
  AssertEquals('bar', e.Current.Second);
  AssertTrue  (e.MoveNext);
  AssertEquals(6,     e.Current.First);
  AssertEquals('baz', e.Current.Second);
  AssertFalse (e.MoveNext);
end;
{$ENDIF}

initialization
  RegisterTest(TutlLinqTests.Suite);
{$ENDIF}

end.