Home | History | Annotate | Download | only in Antlr3.Runtime.Tests 
      1 unit Antlr.Runtime.Tools.Tests;
      2 {
      3 
      4   Delphi DUnit Test Case
      5   ----------------------
      6   This unit contains a skeleton test case class generated by the Test Case Wizard.
      7   Modify the generated code to correctly setup and call the methods from the unit
      8   being tested.
      9 
     10 }
     11 
     12 interface
     13 
     14 uses
     15   SysUtils,
     16   TestFramework,
     17   Generics.Defaults,
     18   Generics.Collections,
     19   Antlr.Runtime.Tools;
     20 
     21 type
     22   // Test methods for class IANTLRString
     23   TestIANTLRString = class(TTestCase)
     24   strict private
     25     FIANTLRString: IANTLRString;
     26   public
     27     procedure SetUp; override;
     28     procedure TearDown; override;
     29   published
     30     procedure TestGetValue;
     31     procedure TestSetValue;
     32   end;
     33 
     34   // Test methods for class TANTLRString
     35   TestTANTLRString = class(TTestCase)
     36   strict private
     37     FANTLRString: TANTLRString;
     38   public
     39     procedure SetUp; override;
     40     procedure TearDown; override;
     41   published
     42     procedure TestToString;
     43   end;
     44 
     45   // Test methods for class ICloneable
     46   TestICloneable = class(TTestCase)
     47   strict private
     48     FICloneable: ICloneable;
     49   public
     50     procedure SetUp; override;
     51     procedure TearDown; override;
     52   published
     53     procedure TestClone;
     54   end;
     55 
     56   // Test methods for class IList
     57   TestIList = class(TTestCase)
     58   strict private
     59     FIList: IList<Integer>;
     60   public
     61     procedure SetUp; override;
     62     procedure TearDown; override;
     63   published
     64     procedure TestGetCapacity;
     65     procedure TestSetCapacity;
     66     procedure TestGetCount;
     67     procedure TestSetCount;
     68     procedure TestGetItem;
     69     procedure TestSetItem;
     70     procedure TestAdd;
     71     procedure TestAddRange;
     72     procedure TestInsert;
     73     procedure TestRemove;
     74     procedure TestDelete;
     75     procedure TestDeleteRange;
     76     procedure TestClear;
     77     procedure TestContains;
     78     procedure TestIndexOf;
     79   end;
     80 
     81   // Test methods for class IDictionary
     82   TestIDictionary = class(TTestCase)
     83   strict private
     84     FIDictionary: IDictionary<String, Integer>;
     85   public
     86     procedure SetUp; override;
     87     procedure TearDown; override;
     88   published
     89     procedure TestGetItem;
     90     procedure TestSetItem;
     91     procedure TestGetCount;
     92     procedure TestAdd;
     93     procedure TestRemove;
     94     procedure TestTryGetValue;
     95     procedure TestContainsKey;
     96     procedure TestContainsValue;
     97     procedure TestEnumeration;
     98   end;
     99 
    100   // Test methods for record TLocalStorage
    101   TestTLocalStorage = class(TTestCase)
    102   published
    103     procedure TestLocalIntegerStorage;
    104     procedure TestLocalInterfaceStorage;
    105   end;
    106 
    107 implementation
    108 
    109 type
    110   IFoo = interface(IANTLRInterface)
    111   ['{48E3FC72-4E63-46D8-8450-A561ECF76995}']
    112     function GetValue: String;
    113     procedure SetValue(const V: String);
    114     property Value: String read GetValue write SetValue;
    115   end;
    116 
    117   TFoo = class(TANTLRObject, ICloneable, IFoo)
    118     FValue: String;
    119     function GetValue: String;
    120     procedure SetValue(const V: String);
    121     function Clone: IANTLRInterface;
    122   end;
    123 
    124 function TFoo.GetValue: String;
    125 begin
    126   Result := FValue;
    127 end;
    128 
    129 procedure TFoo.SetValue(const V: String);
    130 begin
    131   FValue := V;
    132 end;
    133 
    134 function TFoo.Clone: IANTLRInterface;
    135 var
    136   Foo: IFoo;
    137 begin
    138   Foo := TFoo.Create;
    139   Foo.Value := FValue;
    140   Result := Foo;
    141 end;
    142 
    143 procedure TestIANTLRString.SetUp;
    144 begin
    145   FIANTLRString := TANTLRString.Create('foo');
    146 end;
    147 
    148 procedure TestIANTLRString.TearDown;
    149 begin
    150   FIANTLRString := nil;
    151 end;
    152 
    153 procedure TestIANTLRString.TestGetValue;
    154 var
    155   ReturnValue: string;
    156 begin
    157   ReturnValue := FIANTLRString.GetValue;
    158   CheckEquals(ReturnValue,'foo');
    159 end;
    160 
    161 procedure TestIANTLRString.TestSetValue;
    162 var
    163   Value: string;
    164 begin
    165   Value := 'bar';
    166   FIANTLRString.SetValue(Value);
    167   CheckEquals(FIANTLRString.Value,'bar');
    168 end;
    169 
    170 procedure TestTANTLRString.SetUp;
    171 begin
    172   FANTLRString := TANTLRString.Create('foo');
    173 end;
    174 
    175 procedure TestTANTLRString.TearDown;
    176 begin
    177   FANTLRString.Free;
    178   FANTLRString := nil;
    179 end;
    180 
    181 procedure TestTANTLRString.TestToString;
    182 var
    183   ReturnValue: string;
    184 begin
    185   ReturnValue := FANTLRString.ToString;
    186   CheckEquals(ReturnValue,'foo');
    187 end;
    188 
    189 procedure TestICloneable.SetUp;
    190 var
    191   Foo: IFoo;
    192 begin
    193   Foo := TFoo.Create;
    194   Foo.Value := 'original';
    195   FICloneable := Foo as ICloneable;
    196 end;
    197 
    198 procedure TestICloneable.TearDown;
    199 begin
    200   FICloneable := nil;
    201 end;
    202 
    203 procedure TestICloneable.TestClone;
    204 var
    205   ReturnValue: IANTLRInterface;
    206 begin
    207   ReturnValue := FICloneable.Clone;
    208   Check(Supports(ReturnValue, IFoo));
    209   CheckEquals((ReturnValue as IFoo).Value,(FICloneable as IFoo).Value);
    210 end;
    211 
    212 procedure TestIList.SetUp;
    213 begin
    214   FIList := TList<Integer>.Create;
    215 end;
    216 
    217 procedure TestIList.TearDown;
    218 begin
    219   FIList := nil;
    220 end;
    221 
    222 procedure TestIList.TestGetCapacity;
    223 var
    224   ReturnValue: Integer;
    225 begin
    226   FIList.Capacity := 100;
    227   ReturnValue := FIList.GetCapacity;
    228   CheckEquals(ReturnValue,100);
    229 end;
    230 
    231 procedure TestIList.TestSetCapacity;
    232 var
    233   Value: Integer;
    234 begin
    235   Value := 100;
    236   FIList.SetCapacity(Value);
    237   CheckEquals(FIList.Capacity,100);
    238 end;
    239 
    240 procedure TestIList.TestGetCount;
    241 var
    242   ReturnValue: Integer;
    243 begin
    244   FIList.Clear;
    245   FIList.Add(123);
    246   ReturnValue := FIList.GetCount;
    247   CheckEquals(ReturnValue,1);
    248 end;
    249 
    250 procedure TestIList.TestSetCount;
    251 var
    252   Value: Integer;
    253 begin
    254   Value := 4;
    255   FIList.SetCount(Value);
    256   CheckEquals(FIList.Count,4);
    257 end;
    258 
    259 procedure TestIList.TestGetItem;
    260 var
    261   ReturnValue: Integer;
    262   Index: Integer;
    263 begin
    264   FIList.Clear;
    265   FIList.Add(100);
    266   FIList.Add(200);
    267   FIList.Add(300);
    268   FIList.Add(400);
    269   Index := 2;
    270   ReturnValue := FIList.GetItem(Index);
    271   CheckEquals(ReturnValue,300);
    272 end;
    273 
    274 procedure TestIList.TestSetItem;
    275 var
    276   Value: Integer;
    277   Index: Integer;
    278 begin
    279   FIList.Clear;
    280   FIList.Add(100);
    281   FIList.Add(200);
    282   FIList.Add(300);
    283   FIList.Add(400);
    284   Index := 3;
    285   Value := 333;
    286   FIList.SetItem(Index, Value);
    287   CheckEquals(FIList.Items[3],333);
    288 end;
    289 
    290 procedure TestIList.TestAdd;
    291 var
    292   ReturnValue: Integer;
    293   Value: Integer;
    294 begin
    295   FIList.Clear;
    296   Value := 3;
    297   ReturnValue := FIList.Add(Value);
    298   CheckEquals(ReturnValue,0);
    299 end;
    300 
    301 procedure TestIList.TestAddRange;
    302 var
    303   Values: array [0..3] of Integer;
    304 begin
    305   FIList.Clear;
    306   Values[0] := 111;
    307   Values[1] := 222;
    308   Values[2] := 333;
    309   Values[3] := 444;
    310   FIList.AddRange(Values);
    311   CheckEquals(FIList[0],111);
    312   CheckEquals(FIList[1],222);
    313   CheckEquals(FIList[2],333);
    314   CheckEquals(FIList[3],444);
    315 end;
    316 
    317 procedure TestIList.TestInsert;
    318 var
    319   Value: Integer;
    320   Index: Integer;
    321 begin
    322   FIList.Clear;
    323   FIList.Add(100);
    324   FIList.Add(200);
    325   FIList.Add(300);
    326   FIList.Add(400);
    327   Index := 2;
    328   Value := 250;
    329   FIList.Insert(Index, Value);
    330   CheckEquals(FIList[1],200);
    331   CheckEquals(FIList[2],250);
    332   CheckEquals(FIList[3],300);
    333 end;
    334 
    335 procedure TestIList.TestRemove;
    336 var
    337   ReturnValue: Integer;
    338   Value: Integer;
    339 begin
    340   FIList.Clear;
    341   FIList.Add(100);
    342   FIList.Add(200);
    343   FIList.Add(300);
    344   FIList.Add(400);
    345   Value := 300;
    346   ReturnValue := FIList.Remove(Value);
    347   CheckEquals(ReturnValue,2);
    348 end;
    349 
    350 procedure TestIList.TestDelete;
    351 var
    352   Index: Integer;
    353 begin
    354   FIList.Clear;
    355   FIList.Add(100);
    356   FIList.Add(200);
    357   FIList.Add(300);
    358   FIList.Add(400);
    359   Index := 2;
    360   FIList.Delete(Index);
    361   CheckEquals(FIList[2],400);
    362 end;
    363 
    364 procedure TestIList.TestDeleteRange;
    365 var
    366   ACount: Integer;
    367   AIndex: Integer;
    368 begin
    369   FIList.Clear;
    370   FIList.Add(100);
    371   FIList.Add(200);
    372   FIList.Add(300);
    373   FIList.Add(400);
    374   AIndex := 1;
    375   ACount := 2;
    376   FIList.DeleteRange(AIndex, ACount);
    377   CheckEquals(FIlist[0],100);
    378   CheckEquals(FIlist[1],400);
    379 end;
    380 
    381 procedure TestIList.TestClear;
    382 begin
    383   FIList.Clear;
    384   FIList.Add(100);
    385   FIList.Add(200);
    386   FIList.Add(300);
    387   FIList.Add(400);
    388   FIList.Clear;
    389   CheckEquals(FIList.Count,0);
    390 end;
    391 
    392 procedure TestIList.TestContains;
    393 var
    394   ReturnValue: Boolean;
    395   Value: Integer;
    396 begin
    397   FIList.Clear;
    398   FIList.Add(100);
    399   FIList.Add(200);
    400   FIList.Add(300);
    401   FIList.Add(400);
    402   Value := 200;
    403   ReturnValue := FIList.Contains(Value);
    404   CheckTrue(ReturnValue);
    405   Value := 250;
    406   ReturnValue := FIList.Contains(Value);
    407   CheckFalse(ReturnValue);
    408 end;
    409 
    410 procedure TestIList.TestIndexOf;
    411 var
    412   ReturnValue: Integer;
    413   Value: Integer;
    414 begin
    415   FIList.Clear;
    416   FIList.Add(100);
    417   FIList.Add(200);
    418   FIList.Add(300);
    419   FIList.Add(400);
    420   Value := 300;
    421   ReturnValue := FIList.IndexOf(Value);
    422   CheckEquals(ReturnValue,2);
    423   Value := 301;
    424   ReturnValue := FIList.IndexOf(Value);
    425   CheckEquals(ReturnValue,-1);
    426 end;
    427 
    428 procedure TestIDictionary.SetUp;
    429 begin
    430   FIDictionary := TDictionary<String, Integer>.Create;
    431   FIDictionary.Add('Foo',1);
    432   FIDictionary.Add('Bar',3);
    433   FIDictionary.Add('Baz',7);
    434   FIDictionary.Add('Zip',7);
    435 end;
    436 
    437 procedure TestIDictionary.TearDown;
    438 begin
    439   FIDictionary := nil;
    440 end;
    441 
    442 procedure TestIDictionary.TestGetItem;
    443 var
    444   ReturnValue: Integer;
    445   Key: String;
    446 begin
    447   Key := 'Baz';
    448   ReturnValue := FIDictionary.GetItem(Key);
    449   CheckEquals(ReturnValue,7);
    450 end;
    451 
    452 procedure TestIDictionary.TestSetItem;
    453 var
    454   Value: Integer;
    455   Key: String;
    456 begin
    457   Key := 'Bar';
    458   Value := 20;
    459   FIDictionary.SetItem(Key, Value);
    460   CheckEquals(FIDictionary['Bar'],20);
    461 end;
    462 
    463 procedure TestIDictionary.TestGetCount;
    464 var
    465   ReturnValue: Integer;
    466 begin
    467   ReturnValue := FIDictionary.GetCount;
    468   CheckEquals(ReturnValue,4);
    469 end;
    470 
    471 procedure TestIDictionary.TestAdd;
    472 var
    473   Value: Integer;
    474   Key: String;
    475 begin
    476   Key := 'Key';
    477   Value := -1;
    478   FIDictionary.Add(Key, Value);
    479   CheckEquals(FIDictionary['Key'],-1);
    480 end;
    481 
    482 procedure TestIDictionary.TestRemove;
    483 var
    484   Key: String;
    485 begin
    486   Key := 'Bar';
    487   FIDictionary.Remove(Key);
    488   CheckEquals(FIDictionary.Count,3);
    489 end;
    490 
    491 procedure TestIDictionary.TestTryGetValue;
    492 var
    493   ReturnValue: Boolean;
    494   Value: Integer;
    495   Key: String;
    496 begin
    497   Key := 'Zip';
    498   ReturnValue := FIDictionary.TryGetValue(Key, Value);
    499   CheckTrue(ReturnValue);
    500   CheckEquals(Value,7);
    501 
    502   Key := 'Oops';
    503   ReturnValue := FIDictionary.TryGetValue(Key, Value);
    504   CheckFalse(ReturnValue);
    505 end;
    506 
    507 procedure TestIDictionary.TestContainsKey;
    508 var
    509   ReturnValue: Boolean;
    510   Key: String;
    511 begin
    512   Key := 'Foo';
    513   ReturnValue := FIDictionary.ContainsKey(Key);
    514   CheckTrue(ReturnValue);
    515 
    516   Key := 'foo';
    517   ReturnValue := FIDictionary.ContainsKey(Key);
    518   CheckFalse(ReturnValue);
    519 end;
    520 
    521 procedure TestIDictionary.TestContainsValue;
    522 var
    523   ReturnValue: Boolean;
    524   Value: Integer;
    525 begin
    526   Value := 3;
    527   ReturnValue := FIDictionary.ContainsValue(Value);
    528   CheckTrue(ReturnValue);
    529 
    530   Value := 2;
    531   ReturnValue := FIDictionary.ContainsValue(Value);
    532   CheckFalse(ReturnValue);
    533 end;
    534 
    535 procedure TestIDictionary.TestEnumeration;
    536 var
    537   Pair: TPair<String, Integer>;
    538   Foo, Bar, Baz, Zip: Boolean;
    539 begin
    540   Foo := False;
    541   Bar := False;
    542   Baz := False;
    543   Zip := False;
    544 
    545   for Pair in FIDictionary do
    546   begin
    547     if (Pair.Key = 'Foo') then
    548     begin
    549       Foo := True;
    550       CheckEquals(Pair.Value, 1);
    551     end
    552     else
    553     if (Pair.Key = 'Bar') then
    554     begin
    555       Bar := True;
    556       CheckEquals(Pair.Value, 3);
    557     end
    558     else
    559     if (Pair.Key = 'Baz') then
    560     begin
    561       Baz := True;
    562       CheckEquals(Pair.Value, 7);
    563     end
    564     else
    565     if (Pair.Key = 'Zip') then
    566     begin
    567       Zip := True;
    568       CheckEquals(Pair.Value, 7);
    569     end
    570     else
    571       Check(False, 'Unknown key in dictionary');
    572   end;
    573   CheckTrue(Foo);
    574   CheckTrue(Bar);
    575   CheckTrue(Baz);
    576   CheckTrue(Zip);
    577 end;
    578 
    579 { TestTLocalStorage }
    580 
    581 procedure TestTLocalStorage.TestLocalIntegerStorage;
    582 var
    583   Locals: TLocalStorage;
    584 begin
    585   Locals.Initialize;
    586   try
    587     Locals.AsInteger['x'] := 2;
    588     Locals.AsInteger['X'] := 3;
    589     CheckEquals(2, Locals.AsInteger['x']);
    590     CheckEquals(3, Locals.AsInteger['X']);
    591     CheckEquals(0, Locals.AsInteger['y']);
    592     Locals.AsInteger['X'] := Locals.AsInteger['x'] * 2;
    593     CheckEquals(4, Locals.AsInteger['X']);
    594     CheckEquals(2, Locals.Count);
    595   finally
    596     Locals.Finalize;
    597   end;
    598 end;
    599 
    600 procedure TestTLocalStorage.TestLocalInterfaceStorage;
    601 var
    602   Locals: TLocalStorage;
    603 begin
    604   Locals.Initialize;
    605   try
    606     { Local variable Z is never accessed again. We add it to check that there
    607       will be no memory leak. }
    608     Locals['Z'] := TANTLRString.Create('Value Z');
    609 
    610     Locals['x'] := TANTLRString.Create('Value x');
    611     Locals['X'] := TANTLRString.Create('Value X');
    612     CheckEquals('Value x', (Locals['x'] as IANTLRString).Value);
    613     CheckEquals('Value X', (Locals['X'] as IANTLRString).Value);
    614     Check(Locals['y'] = nil);
    615 
    616     Locals['X'] := TANTLRString.Create(
    617       (Locals['X'] as IANTLRString).Value + ' Update');
    618     CheckEquals('Value X Update', (Locals['X'] as IANTLRString).Value);
    619     CheckEquals(3, Locals.Count);
    620   finally
    621     Locals.Finalize;
    622   end;
    623 end;
    624 
    625 initialization
    626   // Register any test cases with the test runner
    627   RegisterTest(TestIANTLRString.Suite);
    628   RegisterTest(TestTANTLRString.Suite);
    629   RegisterTest(TestICloneable.Suite);
    630   RegisterTest(TestIList.Suite);
    631   RegisterTest(TestIDictionary.Suite);
    632   RegisterTest(TestTLocalStorage.Suite);
    633 end.
    634