paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-09-12 19:49:17 +02:00
Code Issues Packages Projects Releases Wiki Activity

* Adapted tests to use expression objects where needed

Browse Source 
git-svn-id: trunk@22085 -
This commit is contained in:
michael 2012-08-15 12:21:52 +00:00
parent 06b092280e
commit 0801287956
3 changed files with 333 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

282
packages/fcl-passrc/tests/tcstatements.pas
View File

@ -71,6 +71,16 @@ Type
Procedure TestCaseElseBlock2Assignments;
Procedure TestCaseIfCaseElse;
Procedure TestCaseIfElse;
Procedure TestRaise;
Procedure TestRaiseEmpty;
Procedure TestRaiseAt;
Procedure TestTryFinally;
Procedure TestTryFinallyEmpty;
Procedure TestTryFinallyNested;
procedure TestTryExcept;
procedure TestTryExceptEmpty;
Procedure TestTryExceptOn;
Procedure TestTryExceptOn2;
end;
implementation
@ -666,6 +676,8 @@ begin
DeclareVar('integer');
TestStatement(['case a of','1 : ;','end;']);
C:=AssertStatement('Case statement',TpasImplCaseOf) as TpasImplCaseOf;
AssertNotNull('Have case expression',C.CaseExpr);
AssertExpression('Case expression',C.CaseExpr,pekIdent,'a');
AssertNull('No else branch',C.ElseBranch);
AssertEquals('One case label',1,C.Elements.Count);
AssertEquals('Correct case for case label',TPasImplCaseStatement,TPasElement(C.Elements[0]).ClassType);
@ -686,6 +698,8 @@ begin
DeclareVar('integer');
TestStatement(['case a of','1,2 : ;','end;']);
C:=AssertStatement('Case statement',TpasImplCaseOf) as TpasImplCaseOf;
AssertNotNull('Have case expression',C.CaseExpr);
AssertExpression('Case expression',C.CaseExpr,pekIdent,'a');
AssertNull('No else branch',C.ElseBranch);
AssertEquals('One case label',1,C.Elements.Count);
AssertEquals('Correct case for case label',TPasImplCaseStatement,TPasElement(C.Elements[0]).ClassType);
@ -706,6 +720,8 @@ begin
DeclareVar('integer');
TestStatement(['case a of','1..3 : ;','end;']);
C:=AssertStatement('Case statement',TpasImplCaseOf) as TpasImplCaseOf;
AssertNotNull('Have case expression',C.CaseExpr);
AssertExpression('Case expression',C.CaseExpr,pekIdent,'a');
AssertNull('No else branch',C.ElseBranch);
AssertEquals('One case label',1,C.Elements.Count);
AssertEquals('Correct case for case label',TPasImplCaseStatement,TPasElement(C.Elements[0]).ClassType);
@ -725,6 +741,8 @@ begin
DeclareVar('integer');
TestStatement(['case a of','1..3,5 : ;','end;']);
C:=AssertStatement('Case statement',TpasImplCaseOf) as TpasImplCaseOf;
AssertNotNull('Have case expression',C.CaseExpr);
AssertExpression('Case expression',C.CaseExpr,pekIdent,'a');
AssertNull('No else branch',C.ElseBranch);
AssertEquals('One case label',1,C.Elements.Count);
AssertEquals('Correct case for case label',TPasImplCaseStatement,TPasElement(C.Elements[0]).ClassType);
@ -745,6 +763,8 @@ begin
DeclareVar('integer');
TestStatement(['case a of','1 : ;','2 : ;','end;']);
C:=AssertStatement('Case statement',TpasImplCaseOf) as TpasImplCaseOf;
AssertNotNull('Have case expression',C.CaseExpr);
AssertExpression('Case expression',C.CaseExpr,pekIdent,'a');
AssertNull('No else branch',C.ElseBranch);
AssertEquals('Two case labels',2,C.Elements.Count);
AssertEquals('Correct case for case label 1',TPasImplCaseStatement,TPasElement(C.Elements[0]).ClassType);
@ -773,6 +793,8 @@ begin
DeclareVar('integer');
TestStatement(['case a of','1 : begin end;','end;']);
C:=AssertStatement('Case statement',TpasImplCaseOf) as TpasImplCaseOf;
AssertNotNull('Have case expression',C.CaseExpr);
AssertExpression('Case expression',C.CaseExpr,pekIdent,'a');
AssertNull('No else branch',C.ElseBranch);
AssertEquals('Two case labels',1,C.Elements.Count);
AssertEquals('Correct case for case label 1',TPasImplCaseStatement,TPasElement(C.Elements[0]).ClassType);
@ -797,6 +819,8 @@ begin
DeclareVar('integer');
TestStatement(['case a of','1 : begin end;','else',' end;']);
C:=AssertStatement('Case statement',TpasImplCaseOf) as TpasImplCaseOf;
AssertNotNull('Have case expression',C.CaseExpr);
AssertExpression('Case expression',C.CaseExpr,pekIdent,'a');
AssertEquals('Two case labels',2,C.Elements.Count);
AssertEquals('Correct case for case label 1',TPasImplCaseStatement,TPasElement(C.Elements[0]).ClassType);
S:=TPasImplCaseStatement(C.Elements[0]);
@ -821,6 +845,8 @@ begin
DeclareVar('integer');
TestStatement(['case a of','1 : begin end;','else','a:=1',' end;']);
C:=AssertStatement('Case statement',TpasImplCaseOf) as TpasImplCaseOf;
AssertNotNull('Have case expression',C.CaseExpr);
AssertExpression('Case expression',C.CaseExpr,pekIdent,'a');
AssertEquals('Two case labels',2,C.Elements.Count);
AssertEquals('Correct case for case label 1',TPasImplCaseStatement,TPasElement(C.Elements[0]).ClassType);
S:=TPasImplCaseStatement(C.Elements[0]);
@ -846,6 +872,8 @@ begin
DeclareVar('integer');
TestStatement(['case a of','1 : begin end;','else','a:=1;','a:=32;',' end;']);
C:=AssertStatement('Case statement',TpasImplCaseOf) as TpasImplCaseOf;
AssertNotNull('Have case expression',C.CaseExpr);
AssertExpression('Case expression',C.CaseExpr,pekIdent,'a');
AssertEquals('Two case labels',2,C.Elements.Count);
AssertEquals('Correct case for case label 1',TPasImplCaseStatement,TPasElement(C.Elements[0]).ClassType);
S:=TPasImplCaseStatement(C.Elements[0]);
@ -872,6 +900,8 @@ begin
DeclareVar('boolean','b');
TestStatement(['case a of','1 : if b then',' begin end;','else',' end;']);
C:=AssertStatement('Case statement',TpasImplCaseOf) as TpasImplCaseOf;
AssertNotNull('Have case expression',C.CaseExpr);
AssertExpression('Case expression',C.CaseExpr,pekIdent,'a');
AssertEquals('Two case labels',2,C.Elements.Count);
AssertNotNull('Have else branch',C.ElseBranch);
AssertEquals('Correct else branch class',TPasImplCaseElse,C.ElseBranch.ClassType);
@ -889,6 +919,8 @@ begin
DeclareVar('boolean','b');
TestStatement(['case a of','1 : if b then',' begin end','else','begin','end',' end;']);
C:=AssertStatement('Case statement',TpasImplCaseOf) as TpasImplCaseOf;
AssertNotNull('Have case expression',C.CaseExpr);
AssertExpression('Case expression',C.CaseExpr,pekIdent,'a');
AssertEquals('Two case labels',1,C.Elements.Count);
AssertNull('Have no else branch',C.ElseBranch);
S:=TPasImplCaseStatement(C.Elements[0]);
@ -899,6 +931,256 @@ begin
AssertNotNull('If statement has else block',TPasImplIfElse(S.Elements[0]).ElseBranch);
end;
procedure TTestStatementParser.TestRaise;
Var
R : TPasImplRaise;
begin
DeclareVar('Exception');
TestStatement('Raise A;');
R:=AssertStatement('Raise statement',TPasImplRaise) as TPasImplRaise;
AssertEquals(0,R.Elements.Count);
AssertNotNull(R.ExceptObject);
AssertNull(R.ExceptAddr);
AssertExpression('Expression object',R.ExceptObject,pekIdent,'A');
end;
procedure TTestStatementParser.TestRaiseEmpty;
Var
R : TPasImplRaise;
begin
TestStatement('Raise;');
R:=AssertStatement('Raise statement',TPasImplRaise) as TPasImplRaise;
AssertEquals(0,R.Elements.Count);
AssertNull(R.ExceptObject);
AssertNull(R.ExceptAddr);
end;
procedure TTestStatementParser.TestRaiseAt;
Var
R : TPasImplRaise;
begin
DeclareVar('Exception');
DeclareVar('Pointer','B');
TestStatement('Raise A at B;');
R:=AssertStatement('Raise statement',TPasImplRaise) as TPasImplRaise;
AssertEquals(0,R.Elements.Count);
AssertNotNull(R.ExceptObject);
AssertNotNull(R.ExceptAddr);
AssertExpression('Expression object',R.ExceptAddr,pekIdent,'B');
end;
procedure TTestStatementParser.TestTryFinally;
Var
T : TPasImplTry;
S : TPasImplSimple;
F : TPasImplTryFinally;
begin
TestStatement(['Try',' DoSomething;','finally',' DoSomethingElse','end']);
T:=AssertStatement('Try statement',TPasImplTry) as TPasImplTry;
AssertEquals(1,T.Elements.Count);
AssertNotNull(T.FinallyExcept);
AssertNull(T.ElseBranch);
AssertNotNull(T.Elements[0]);
AssertEquals('Simple statement',TPasImplSimple,TPasElement(T.Elements[0]).ClassType);
S:=TPasImplSimple(T.Elements[0]);
AssertExpression('DoSomething call',S.Expr,pekIdent,'DoSomething');
AssertEquals('Simple statement',TPasImplSimple,TPasElement(T.Elements[0]).ClassType);
AssertEquals('Finally statement',TPasImplTryFinally,T.FinallyExcept.ClassType);
F:=TPasImplTryFinally(T.FinallyExcept);
AssertEquals(1,F.Elements.Count);
AssertEquals('Simple statement',TPasImplSimple,TPasElement(F.Elements[0]).ClassType);
S:=TPasImplSimple(F.Elements[0]);
AssertExpression('DoSomethingElse call',S.Expr,pekIdent,'DoSomethingElse');
end;
procedure TTestStatementParser.TestTryFinallyEmpty;
Var
T : TPasImplTry;
F : TPasImplTryFinally;
begin
TestStatement(['Try','finally','end;']);
T:=AssertStatement('Try statement',TPasImplTry) as TPasImplTry;
AssertEquals(0,T.Elements.Count);
AssertNotNull(T.FinallyExcept);
AssertNull(T.ElseBranch);
AssertEquals('Finally statement',TPasImplTryFinally,T.FinallyExcept.ClassType);
F:=TPasImplTryFinally(T.FinallyExcept);
AssertEquals(0,F.Elements.Count);
end;
procedure TTestStatementParser.TestTryFinallyNested;
Var
T : TPasImplTry;
S : TPasImplSimple;
F : TPasImplTryFinally;
begin
TestStatement(['Try',' DoSomething1;',' Try',' DoSomething2;',' finally',' DoSomethingElse2',' end;','Finally',' DoSomethingElse1','end']);
T:=AssertStatement('Try statement',TPasImplTry) as TPasImplTry;
AssertEquals(2,T.Elements.Count);
AssertNotNull(T.FinallyExcept);
AssertNull(T.ElseBranch);
AssertNotNull(T.Elements[0]);
AssertEquals('Simple statement',TPasImplSimple,TPasElement(T.Elements[0]).ClassType);
S:=TPasImplSimple(T.Elements[0]);
AssertExpression('DoSomething call',S.Expr,pekIdent,'DoSomething1');
AssertEquals('Simple statement',TPasImplSimple,TPasElement(T.Elements[0]).ClassType);
AssertEquals('Finally statement',TPasImplTryFinally,T.FinallyExcept.ClassType);
F:=TPasImplTryFinally(T.FinallyExcept);
AssertEquals(1,F.Elements.Count);
AssertEquals('Simple statement',TPasImplSimple,TPasElement(F.Elements[0]).ClassType);
S:=TPasImplSimple(F.Elements[0]);
AssertExpression('DoSomethingElse call',S.Expr,pekIdent,'DoSomethingElse1');
// inner statement
AssertNotNull(T.Elements[1]);
AssertEquals('Nested try statement',TPasImplTry,TPasElement(T.Elements[1]).ClassType);
T:=TPasImplTry(T.Elements[1]);
AssertEquals(1,T.Elements.Count);
AssertNotNull(T.FinallyExcept);
AssertNull(T.ElseBranch);
AssertNotNull(T.Elements[0]);
AssertEquals('Simple statement',TPasImplSimple,TPasElement(T.Elements[0]).ClassType);
S:=TPasImplSimple(T.Elements[0]);
AssertExpression('DoSomething call',S.Expr,pekIdent,'DoSomething2');
AssertEquals('Simple statement',TPasImplSimple,TPasElement(T.Elements[0]).ClassType);
AssertEquals('Finally statement',TPasImplTryFinally,T.FinallyExcept.ClassType);
F:=TPasImplTryFinally(T.FinallyExcept);
AssertEquals(1,F.Elements.Count);
AssertEquals('Simple statement',TPasImplSimple,TPasElement(F.Elements[0]).ClassType);
S:=TPasImplSimple(F.Elements[0]);
AssertExpression('DoSomethingElse call',S.Expr,pekIdent,'DoSomethingElse2');
end;
procedure TTestStatementParser.TestTryExcept;
Var
T : TPasImplTry;
S : TPasImplSimple;
E : TPasImplTryExcept;
begin
TestStatement(['Try',' DoSomething;','except',' DoSomethingElse','end']);
T:=AssertStatement('Try statement',TPasImplTry) as TPasImplTry;
AssertEquals(1,T.Elements.Count);
AssertNotNull(T.FinallyExcept);
AssertNull(T.ElseBranch);
AssertNotNull(T.Elements[0]);
AssertEquals('Simple statement',TPasImplSimple,TPasElement(T.Elements[0]).ClassType);
S:=TPasImplSimple(T.Elements[0]);
AssertExpression('DoSomething call',S.Expr,pekIdent,'DoSomething');
AssertEquals('Simple statement',TPasImplSimple,TPasElement(T.Elements[0]).ClassType);
AssertEquals('Except statement',TPasImplTryExcept,T.FinallyExcept.ClassType);
E:=TPasImplTryExcept(T.FinallyExcept);
AssertEquals(1,E.Elements.Count);
AssertEquals('Simple statement',TPasImplSimple,TPasElement(E.Elements[0]).ClassType);
S:=TPasImplSimple(E.Elements[0]);
AssertExpression('DoSomethingElse call',S.Expr,pekIdent,'DoSomethingElse');
end;
procedure TTestStatementParser.TestTryExceptEmpty;
Var
T : TPasImplTry;
E : TPasImplTryExcept;
begin
TestStatement(['Try','except','end;']);
T:=AssertStatement('Try statement',TPasImplTry) as TPasImplTry;
AssertEquals(0,T.Elements.Count);
AssertNotNull(T.FinallyExcept);
AssertNull(T.ElseBranch);
AssertEquals('Except statement',TPasImplTryExcept,T.FinallyExcept.ClassType);
E:=TPasImplTryExcept(T.FinallyExcept);
AssertEquals(0,E.Elements.Count);
end;
procedure TTestStatementParser.TestTryExceptOn;
Var
T : TPasImplTry;
S : TPasImplSimple;
E : TPasImplTryExcept;
O : TPasImplExceptOn;
begin
TestStatement(['Try',' DoSomething;','except','On E : Exception do','DoSomethingElse;','end']);
T:=AssertStatement('Try statement',TPasImplTry) as TPasImplTry;
AssertEquals(1,T.Elements.Count);
AssertNotNull(T.FinallyExcept);
AssertNull(T.ElseBranch);
AssertNotNull(T.Elements[0]);
AssertEquals('Simple statement',TPasImplSimple,TPasElement(T.Elements[0]).ClassType);
S:=TPasImplSimple(T.Elements[0]);
AssertExpression('DoSomething call',S.Expr,pekIdent,'DoSomething');
AssertEquals('Simple statement',TPasImplSimple,TPasElement(T.Elements[0]).ClassType);
AssertEquals('Except statement',TPasImplTryExcept,T.FinallyExcept.ClassType);
E:=TPasImplTryExcept(T.FinallyExcept);
AssertEquals(1,E.Elements.Count);
AssertEquals('Except on handler',TPasImplExceptOn,TPasElement(E.Elements[0]).ClassType);
O:=TPasImplExceptOn(E.Elements[0]);
AssertEquals(1,O.Elements.Count);
AssertEquals('Simple statement',TPasImplSimple,TPasElement(O.Elements[0]).ClassType);
AssertExpression('Exception Variable name',O.VarExpr,pekIdent,'E');
AssertExpression('Exception Type name',O.TypeExpr,pekIdent,'Exception');
S:=TPasImplSimple(O.Elements[0]);
AssertExpression('DoSomethingElse call',S.Expr,pekIdent,'DoSomethingElse');
// AssertEquals('Variable name',
end;
procedure TTestStatementParser.TestTryExceptOn2;
Var
T : TPasImplTry;
S : TPasImplSimple;
E : TPasImplTryExcept;
O : TPasImplExceptOn;
begin
TestStatement(['Try',' DoSomething;','except',
'On E : Exception do','DoSomethingElse;',
'On Y : Exception2 do','DoSomethingElse2;',
'end']);
T:=AssertStatement('Try statement',TPasImplTry) as TPasImplTry;
AssertEquals(1,T.Elements.Count);
AssertNotNull(T.FinallyExcept);
AssertNull(T.ElseBranch);
AssertNotNull(T.Elements[0]);
AssertEquals('Simple statement',TPasImplSimple,TPasElement(T.Elements[0]).ClassType);
S:=TPasImplSimple(T.Elements[0]);
AssertExpression('DoSomething call',S.Expr,pekIdent,'DoSomething');
AssertEquals('Simple statement',TPasImplSimple,TPasElement(T.Elements[0]).ClassType);
AssertEquals('Except statement',TPasImplTryExcept,T.FinallyExcept.ClassType);
E:=TPasImplTryExcept(T.FinallyExcept);
AssertEquals(2,E.Elements.Count);
// Exception handler 1
AssertEquals('Except on handler',TPasImplExceptOn,TPasElement(E.Elements[0]).ClassType);
O:=TPasImplExceptOn(E.Elements[0]);
AssertEquals(1,O.Elements.Count);
AssertEquals('Simple statement',TPasImplSimple,TPasElement(O.Elements[0]).ClassType);
AssertExpression('Exception Variable name',O.VarExpr,pekIdent,'E');
AssertExpression('Exception Type name',O.TypeExpr,pekIdent,'Exception');
S:=TPasImplSimple(O.Elements[0]);
AssertExpression('DoSomethingElse call',S.Expr,pekIdent,'DoSomethingElse');
// Exception handler 2
AssertEquals('Except on handler',TPasImplExceptOn,TPasElement(E.Elements[1]).ClassType);
O:=TPasImplExceptOn(E.Elements[1]);
AssertEquals(1,O.Elements.Count);
AssertEquals('Simple statement',TPasImplSimple,TPasElement(O.Elements[0]).ClassType);
AssertExpression('Exception Variable name',O.VarExpr,pekIdent,'Y');
AssertExpression('Exception Type name',O.TypeExpr,pekIdent,'Exception2');
S:=TPasImplSimple(O.Elements[0]);
AssertExpression('DoSomethingElse call',S.Expr,pekIdent,'DoSomethingElse2');
end;
initialization
RegisterTests([TTestStatementParser]);

31
packages/fcl-passrc/tests/tctypeparser.pas
View File

@ -1185,13 +1185,18 @@ begin
if Length(VariantLabels)=0 then
begin
AssertEquals('Have 1 value',1,Variant1.Values.Count);
AssertEquals('First value is 0','0',Variant1.Values[0]);
AssertNotNull('Assigned value',Variant1.Values[0]);
AssertEquals('Expression',TPrimitiveExpr,TObject(Variant1.Values[0]).CLassType);
AssertExpression('First value is 0',TPasExpr(Variant1.Values[0]),pekNumber,'0');
end
else
begin
AssertEquals('Have correct number of values',Length(VariantLabels),Variant1.Values.Count);
For I:=0 to Length(VariantLabels)-1 do
AssertEquals(Format('Value %d is %s',[i,VariantLabels[i]]),VariantLabels[i],Variant1.Values[I]);
begin
AssertEquals(Format('Expression for variant %d',[I]),TPrimitiveExpr,TObject(Variant1.Values[0]).CLassType);
AssertExpression(Format('Value %d is %s',[i,VariantLabels[i]]),TPasExpr(Variant1.Values[I]),pekNumber,VariantLabels[i]);
end;
end;
AssertNotNull('Have members',Variant1.Members);
AssertNotNull('Have member members',Variant1.Members.Members);
@ -1220,13 +1225,18 @@ begin
if Length(VariantLabels)=0 then
begin
AssertEquals('Variant 2 has 1 value',2,Variant2.Values.Count);
AssertEquals('Variant 2 First value is 0','1',Variant2.Values[0]);
AssertEquals('Expression',TPrimitiveExpr,TObject(Variant2.Values[0]).CLassType);
AssertExpression('First value is 1',TPasExpr(Variant2.Values[0]),pekNumber,'1');
end
else
begin
AssertEquals('Variant 2 Has correct number of values',Length(VariantLabels),Variant2.Values.Count);
For I:=0 to Length(VariantLabels)-1 do
AssertEquals(Format('Variant 2, Value %d is %s',[i,VariantLabels[i]]),VariantLabels[i],Variant2.Values[I]);
begin
AssertEquals(Format('Expression for variant %d',[I]),TPrimitiveExpr,TObject(Variant2.Values[I]).CLassType);
AssertExpression(Format('Value %d is %s',[i,VariantLabels[i]]),TPasExpr(Variant2.Values[I]),pekNumber,VariantLabels[i]);
// AssertEquals(Format('Variant 2, Value %d is %s',[i,VariantLabels[i]]),VariantLabels[i],Variant2.Values[I]);
end;
end;
AssertNotNull('Have members',Variant2.Members);
AssertNotNull('Have member members',Variant2.Members.Members);
@ -1472,7 +1482,10 @@ begin
AssertNotNull('Have variant 1',F);
AssertEquals('Have correct number of values',Length(VariantLabels),F.Values.Count);
For I:=0 to Length(VariantLabels)-1 do
AssertEquals(Format('Value %d is %s',[i,VariantLabels[i]]),VariantLabels[i],F.Values[I]);
begin
AssertEquals(Format('Expression for variant %d',[I]),TPrimitiveExpr,TObject(Variant1.Values[i]).CLassType);
AssertExpression(Format('Value %d is %s',[i,VariantLabels[i]]),TPasExpr(Variant1.Values[I]),pekNumber,VariantLabels[i]);
end;
V:=GetField(0,F);
AssertEquals(MN+'has correct name','y',V.Name);
AssertNotNull(MN+'has not null type',V.VarType);
@ -1501,7 +1514,8 @@ begin
MN:='Nested Variant '+IntToStr(AIndex)+' ';
AssertNotNull('Have variant 1',F);
AssertEquals('Have correct number of values',1,F.Values.Count);
AssertEquals('Value 1 is 0','0',F.Values[I]);
AssertEquals('Expression',TPrimitiveExpr,TObject(F.Values[0]).CLassType);
AssertExpression('First value is 0',TPasExpr(F.Values[0]),pekNumber,'0');
// First variant, Y, record
V:=GetField(0,F);
AssertEquals(MN+'has correct name','y',V.Name);
@ -1515,7 +1529,10 @@ begin
// First field of first variant, i
AssertEquals('Have correct number of values',Length(VariantLabels),F.Values.Count);
For I:=0 to Length(VariantLabels)-1 do
AssertEquals(Format('Value %d is %s',[i,VariantLabels[i]]),VariantLabels[i],F.Values[I]);
begin
AssertEquals(Format('Expression for variant %d',[I]),TPrimitiveExpr,TObject(F.Values[i]).CLassType);
AssertExpression(Format('Value %d is %s',[i,VariantLabels[i]]),TPasExpr(F.Values[I]),pekNumber,VariantLabels[i]);
end;
V:=GetField(0,F);
AssertEquals('Nested Variant 0 has correct name',AFieldName,V.Name);
AssertEquals('Nested variant 0 has correct type',TPasUnresolvedTypeRef,V.VarType.ClassType);

27
packages/fcl-passrc/tests/tcvarparser.pas
View File

@ -28,6 +28,9 @@ Type
Procedure TestSimpleVar;
Procedure TestSimpleVarDeprecated;
Procedure TestSimpleVarPlatform;
Procedure TestSimpleVarInitialized;
procedure TestSimpleVarInitializedDeprecated;
procedure TestSimpleVarInitializedPlatform;
Procedure TestVarProcedure;
Procedure TestVarProcedureDeprecated;
Procedure TestVarRecord;
@ -128,6 +131,30 @@ begin
AssertVariableType('b');
end;
procedure TTestVarParser.TestSimpleVarInitialized;
begin
ParseVar('b = 123','');
AssertVariableType('b');
AssertNotNull(TheVar.expr);
AssertExpression('Variable value',TheVar.expr,pekNumber,'123');
end;
procedure TTestVarParser.TestSimpleVarInitializedDeprecated;
begin
ParseVar('b = 123','deprecated');
AssertVariableType('b');
AssertNotNull(TheVar.expr);
AssertExpression('Variable value',TheVar.expr,pekNumber,'123');
end;
procedure TTestVarParser.TestSimpleVarInitializedPlatform;
begin
ParseVar('b = 123','platform');
AssertVariableType('b');
AssertNotNull(TheVar.expr);
AssertExpression('Variable value',TheVar.expr,pekNumber,'123');
end;
procedure TTestVarParser.TestVarProcedure;
begin
ParseVar('procedure','');