634 lines
12 KiB
ObjectPascal
634 lines
12 KiB
ObjectPascal
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.
|