Sources/Antlr3.Runtime.Tests/Antlr.Runtime.Tools.Tests.pas

unit Antlr.Runtime.Tools.Tests;
{

  Delphi DUnit Test Case
  ----------------------
  This unit contains a skeleton test case class generated by the Test Case Wizard.
  Modify the generated code to correctly setup and call the methods from the unit
  being tested.

}

interface

uses
  SysUtils,
  TestFramework,
  Generics.Defaults,
  Generics.Collections,
  Antlr.Runtime.Tools;

type
  // Test methods for class IANTLRString
  TestIANTLRString = class(TTestCase)
  strict private
    FIANTLRString: IANTLRString;
  public
    procedure SetUp; override;
    procedure TearDown; override;
  published
    procedure TestGetValue;
    procedure TestSetValue;
  end;

  // Test methods for class TANTLRString
  TestTANTLRString = class(TTestCase)
  strict private
    FANTLRString: TANTLRString;
  public
    procedure SetUp; override;
    procedure TearDown; override;
  published
    procedure TestToString;
  end;

  // Test methods for class ICloneable
  TestICloneable = class(TTestCase)
  strict private
    FICloneable: ICloneable;
  public
    procedure SetUp; override;
    procedure TearDown; override;
  published
    procedure TestClone;
  end;

  // Test methods for class IList
  TestIList = class(TTestCase)
  strict private
    FIList: IList<Integer>;
  public
    procedure SetUp; override;
    procedure TearDown; override;
  published
    procedure TestGetCapacity;
    procedure TestSetCapacity;
    procedure TestGetCount;
    procedure TestSetCount;
    procedure TestGetItem;
    procedure TestSetItem;
    procedure TestAdd;
    procedure TestAddRange;
    procedure TestInsert;
    procedure TestRemove;
    procedure TestDelete;
    procedure TestDeleteRange;
    procedure TestClear;
    procedure TestContains;
    procedure TestIndexOf;
  end;

  // Test methods for class IDictionary
  TestIDictionary = class(TTestCase)
  strict private
    FIDictionary: IDictionary<String, Integer>;
  public
    procedure SetUp; override;
    procedure TearDown; override;
  published
    procedure TestGetItem;
    procedure TestSetItem;
    procedure TestGetCount;
    procedure TestAdd;
    procedure TestRemove;
    procedure TestTryGetValue;
    procedure TestContainsKey;
    procedure TestContainsValue;
    procedure TestEnumeration;
  end;

  // Test methods for record TLocalStorage
  TestTLocalStorage = class(TTestCase)
  published
    procedure TestLocalIntegerStorage;
    procedure TestLocalInterfaceStorage;
  end;

implementation

type
  IFoo = interface(IANTLRInterface)
  ['{48E3FC72-4E63-46D8-8450-A561ECF76995}']
    function GetValue: String;
    procedure SetValue(const V: String);
    property Value: String read GetValue write SetValue;
  end;

  TFoo = class(TANTLRObject, ICloneable, IFoo)
    FValue: String;
    function GetValue: String;
    procedure SetValue(const V: String);
    function Clone: IANTLRInterface;
  end;

function TFoo.GetValue: String;
begin
  Result := FValue;
end;

procedure TFoo.SetValue(const V: String);
begin
  FValue := V;
end;

function TFoo.Clone: IANTLRInterface;
var
  Foo: IFoo;
begin
  Foo := TFoo.Create;
  Foo.Value := FValue;
  Result := Foo;
end;

procedure TestIANTLRString.SetUp;
begin
  FIANTLRString := TANTLRString.Create('foo');
end;

procedure TestIANTLRString.TearDown;
begin
  FIANTLRString := nil;
end;

procedure TestIANTLRString.TestGetValue;
var
  ReturnValue: string;
begin
  ReturnValue := FIANTLRString.GetValue;
  CheckEquals(ReturnValue,'foo');
end;

procedure TestIANTLRString.TestSetValue;
var
  Value: string;
begin
  Value := 'bar';
  FIANTLRString.SetValue(Value);
  CheckEquals(FIANTLRString.Value,'bar');
end;

procedure TestTANTLRString.SetUp;
begin
  FANTLRString := TANTLRString.Create('foo');
end;

procedure TestTANTLRString.TearDown;
begin
  FANTLRString.Free;
  FANTLRString := nil;
end;

procedure TestTANTLRString.TestToString;
var
  ReturnValue: string;
begin
  ReturnValue := FANTLRString.ToString;
  CheckEquals(ReturnValue,'foo');
end;

procedure TestICloneable.SetUp;
var
  Foo: IFoo;
begin
  Foo := TFoo.Create;
  Foo.Value := 'original';
  FICloneable := Foo as ICloneable;
end;

procedure TestICloneable.TearDown;
begin
  FICloneable := nil;
end;

procedure TestICloneable.TestClone;
var
  ReturnValue: IANTLRInterface;
begin
  ReturnValue := FICloneable.Clone;
  Check(Supports(ReturnValue, IFoo));
  CheckEquals((ReturnValue as IFoo).Value,(FICloneable as IFoo).Value);
end;

procedure TestIList.SetUp;
begin
  FIList := TList<Integer>.Create;
end;

procedure TestIList.TearDown;
begin
  FIList := nil;
end;

procedure TestIList.TestGetCapacity;
var
  ReturnValue: Integer;
begin
  FIList.Capacity := 100;
  ReturnValue := FIList.GetCapacity;
  CheckEquals(ReturnValue,100);
end;

procedure TestIList.TestSetCapacity;
var
  Value: Integer;
begin
  Value := 100;
  FIList.SetCapacity(Value);
  CheckEquals(FIList.Capacity,100);
end;

procedure TestIList.TestGetCount;
var
  ReturnValue: Integer;
begin
  FIList.Clear;
  FIList.Add(123);
  ReturnValue := FIList.GetCount;
  CheckEquals(ReturnValue,1);
end;

procedure TestIList.TestSetCount;
var
  Value: Integer;
begin
  Value := 4;
  FIList.SetCount(Value);
  CheckEquals(FIList.Count,4);
end;

procedure TestIList.TestGetItem;
var
  ReturnValue: Integer;
  Index: Integer;
begin
  FIList.Clear;
  FIList.Add(100);
  FIList.Add(200);
  FIList.Add(300);
  FIList.Add(400);
  Index := 2;
  ReturnValue := FIList.GetItem(Index);
  CheckEquals(ReturnValue,300);
end;

procedure TestIList.TestSetItem;
var
  Value: Integer;
  Index: Integer;
begin
  FIList.Clear;
  FIList.Add(100);
  FIList.Add(200);
  FIList.Add(300);
  FIList.Add(400);
  Index := 3;
  Value := 333;
  FIList.SetItem(Index, Value);
  CheckEquals(FIList.Items[3],333);
end;

procedure TestIList.TestAdd;
var
  ReturnValue: Integer;
  Value: Integer;
begin
  FIList.Clear;
  Value := 3;
  ReturnValue := FIList.Add(Value);
  CheckEquals(ReturnValue,0);
end;

procedure TestIList.TestAddRange;
var
  Values: array [0..3] of Integer;
begin
  FIList.Clear;
  Values[0] := 111;
  Values[1] := 222;
  Values[2] := 333;
  Values[3] := 444;
  FIList.AddRange(Values);
  CheckEquals(FIList[0],111);
  CheckEquals(FIList[1],222);
  CheckEquals(FIList[2],333);
  CheckEquals(FIList[3],444);
end;

procedure TestIList.TestInsert;
var
  Value: Integer;
  Index: Integer;
begin
  FIList.Clear;
  FIList.Add(100);
  FIList.Add(200);
  FIList.Add(300);
  FIList.Add(400);
  Index := 2;
  Value := 250;
  FIList.Insert(Index, Value);
  CheckEquals(FIList[1],200);
  CheckEquals(FIList[2],250);
  CheckEquals(FIList[3],300);
end;

procedure TestIList.TestRemove;
var
  ReturnValue: Integer;
  Value: Integer;
begin
  FIList.Clear;
  FIList.Add(100);
  FIList.Add(200);
  FIList.Add(300);
  FIList.Add(400);
  Value := 300;
  ReturnValue := FIList.Remove(Value);
  CheckEquals(ReturnValue,2);
end;

procedure TestIList.TestDelete;
var
  Index: Integer;
begin
  FIList.Clear;
  FIList.Add(100);
  FIList.Add(200);
  FIList.Add(300);
  FIList.Add(400);
  Index := 2;
  FIList.Delete(Index);
  CheckEquals(FIList[2],400);
end;

procedure TestIList.TestDeleteRange;
var
  ACount: Integer;
  AIndex: Integer;
begin
  FIList.Clear;
  FIList.Add(100);
  FIList.Add(200);
  FIList.Add(300);
  FIList.Add(400);
  AIndex := 1;
  ACount := 2;
  FIList.DeleteRange(AIndex, ACount);
  CheckEquals(FIlist[0],100);
  CheckEquals(FIlist[1],400);
end;

procedure TestIList.TestClear;
begin
  FIList.Clear;
  FIList.Add(100);
  FIList.Add(200);
  FIList.Add(300);
  FIList.Add(400);
  FIList.Clear;
  CheckEquals(FIList.Count,0);
end;

procedure TestIList.TestContains;
var
  ReturnValue: Boolean;
  Value: Integer;
begin
  FIList.Clear;
  FIList.Add(100);
  FIList.Add(200);
  FIList.Add(300);
  FIList.Add(400);
  Value := 200;
  ReturnValue := FIList.Contains(Value);
  CheckTrue(ReturnValue);
  Value := 250;
  ReturnValue := FIList.Contains(Value);
  CheckFalse(ReturnValue);
end;

procedure TestIList.TestIndexOf;
var
  ReturnValue: Integer;
  Value: Integer;
begin
  FIList.Clear;
  FIList.Add(100);
  FIList.Add(200);
  FIList.Add(300);
  FIList.Add(400);
  Value := 300;
  ReturnValue := FIList.IndexOf(Value);
  CheckEquals(ReturnValue,2);
  Value := 301;
  ReturnValue := FIList.IndexOf(Value);
  CheckEquals(ReturnValue,-1);
end;

procedure TestIDictionary.SetUp;
begin
  FIDictionary := TDictionary<String, Integer>.Create;
  FIDictionary.Add('Foo',1);
  FIDictionary.Add('Bar',3);
  FIDictionary.Add('Baz',7);
  FIDictionary.Add('Zip',7);
end;

procedure TestIDictionary.TearDown;
begin
  FIDictionary := nil;
end;

procedure TestIDictionary.TestGetItem;
var
  ReturnValue: Integer;
  Key: String;
begin
  Key := 'Baz';
  ReturnValue := FIDictionary.GetItem(Key);
  CheckEquals(ReturnValue,7);
end;

procedure TestIDictionary.TestSetItem;
var
  Value: Integer;
  Key: String;
begin
  Key := 'Bar';
  Value := 20;
  FIDictionary.SetItem(Key, Value);
  CheckEquals(FIDictionary['Bar'],20);
end;

procedure TestIDictionary.TestGetCount;
var
  ReturnValue: Integer;
begin
  ReturnValue := FIDictionary.GetCount;
  CheckEquals(ReturnValue,4);
end;

procedure TestIDictionary.TestAdd;
var
  Value: Integer;
  Key: String;
begin
  Key := 'Key';
  Value := -1;
  FIDictionary.Add(Key, Value);
  CheckEquals(FIDictionary['Key'],-1);
end;

procedure TestIDictionary.TestRemove;
var
  Key: String;
begin
  Key := 'Bar';
  FIDictionary.Remove(Key);
  CheckEquals(FIDictionary.Count,3);
end;

procedure TestIDictionary.TestTryGetValue;
var
  ReturnValue: Boolean;
  Value: Integer;
  Key: String;
begin
  Key := 'Zip';
  ReturnValue := FIDictionary.TryGetValue(Key, Value);
  CheckTrue(ReturnValue);
  CheckEquals(Value,7);

  Key := 'Oops';
  ReturnValue := FIDictionary.TryGetValue(Key, Value);
  CheckFalse(ReturnValue);
end;

procedure TestIDictionary.TestContainsKey;
var
  ReturnValue: Boolean;
  Key: String;
begin
  Key := 'Foo';
  ReturnValue := FIDictionary.ContainsKey(Key);
  CheckTrue(ReturnValue);

  Key := 'foo';
  ReturnValue := FIDictionary.ContainsKey(Key);
  CheckFalse(ReturnValue);
end;

procedure TestIDictionary.TestContainsValue;
var
  ReturnValue: Boolean;
  Value: Integer;
begin
  Value := 3;
  ReturnValue := FIDictionary.ContainsValue(Value);
  CheckTrue(ReturnValue);

  Value := 2;
  ReturnValue := FIDictionary.ContainsValue(Value);
  CheckFalse(ReturnValue);
end;

procedure TestIDictionary.TestEnumeration;
var
  Pair: TPair<String, Integer>;
  Foo, Bar, Baz, Zip: Boolean;
begin
  Foo := False;
  Bar := False;
  Baz := False;
  Zip := False;

  for Pair in FIDictionary do
  begin
    if (Pair.Key = 'Foo') then
    begin
      Foo := True;
      CheckEquals(Pair.Value, 1);
    end
    else
    if (Pair.Key = 'Bar') then
    begin
      Bar := True;
      CheckEquals(Pair.Value, 3);
    end
    else
    if (Pair.Key = 'Baz') then
    begin
      Baz := True;
      CheckEquals(Pair.Value, 7);
    end
    else
    if (Pair.Key = 'Zip') then
    begin
      Zip := True;
      CheckEquals(Pair.Value, 7);
    end
    else
      Check(False, 'Unknown key in dictionary');
  end;
  CheckTrue(Foo);
  CheckTrue(Bar);
  CheckTrue(Baz);
  CheckTrue(Zip);
end;

{ TestTLocalStorage }

procedure TestTLocalStorage.TestLocalIntegerStorage;
var
  Locals: TLocalStorage;
begin
  Locals.Initialize;
  try
    Locals.AsInteger['x'] := 2;
    Locals.AsInteger['X'] := 3;
    CheckEquals(2, Locals.AsInteger['x']);
    CheckEquals(3, Locals.AsInteger['X']);
    CheckEquals(0, Locals.AsInteger['y']);
    Locals.AsInteger['X'] := Locals.AsInteger['x'] * 2;
    CheckEquals(4, Locals.AsInteger['X']);
    CheckEquals(2, Locals.Count);
  finally
    Locals.Finalize;
  end;
end;

procedure TestTLocalStorage.TestLocalInterfaceStorage;
var
  Locals: TLocalStorage;
begin
  Locals.Initialize;
  try
    { Local variable Z is never accessed again. We add it to check that there
      will be no memory leak. }
    Locals['Z'] := TANTLRString.Create('Value Z');

    Locals['x'] := TANTLRString.Create('Value x');
    Locals['X'] := TANTLRString.Create('Value X');
    CheckEquals('Value x', (Locals['x'] as IANTLRString).Value);
    CheckEquals('Value X', (Locals['X'] as IANTLRString).Value);
    Check(Locals['y'] = nil);

    Locals['X'] := TANTLRString.Create(
      (Locals['X'] as IANTLRString).Value + ' Update');
    CheckEquals('Value X Update', (Locals['X'] as IANTLRString).Value);
    CheckEquals(3, Locals.Count);
  finally
    Locals.Finalize;
  end;
end;

initialization
  // Register any test cases with the test runner
  RegisterTest(TestIANTLRString.Suite);
  RegisterTest(TestTANTLRString.Suite);
  RegisterTest(TestICloneable.Suite);
  RegisterTest(TestIList.Suite);
  RegisterTest(TestIDictionary.Suite);
  RegisterTest(TestTLocalStorage.Suite);
end.