* Adapted tests to use expression objects where needed

git-svn-id: trunk@22085 -

packages/fcl-passrc/tests/tcstatements.pas

@@ -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]);
 

packages/fcl-passrc/tests/tctypeparser.pas

@@ -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);

packages/fcl-passrc/tests/tcvarparser.pas

@@ -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','');