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

fcl-js: no brackets in var-comma

Browse Source 
git-svn-id: trunk@37578 -
This commit is contained in:
Mattias Gaertner 2017-11-12 14:14:04 +00:00
parent eb7059cea8
commit 2a57480fff
2 changed files with 180 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
packages/fcl-js/src/jswriter.pp
View File

@ -993,7 +993,12 @@ begin
AllowCompact:=TJSBinaryExpression(El).AllowCompact; AllowCompact:=TJSBinaryExpression(El).AllowCompact;
end; end;
If Not (AllowCompact and (woCompact in Options)) then If Not (AllowCompact and (woCompact in Options)) then
S:=' '+S+' '; begin
if El is TJSCommaExpression then
S:=S+' '
else
S:=' '+S+' ';
end;
Write(S); Write(S);
WriteJS(El.B); WriteJS(El.B);
Writer.CurElement:=El; Writer.CurElement:=El;
@ -1449,6 +1454,7 @@ procedure TJSWriter.WriteVariableStatement(El: TJSVariableStatement);
begin begin
Write('var '); Write('var ');
FSkipRoundBrackets:=true;
WriteJS(El.A); WriteJS(El.A);
end; end;

262
packages/fcl-js/tests/tcwriter.pp
View File

@ -134,6 +134,7 @@ type
Procedure TestForStatementFull; Procedure TestForStatementFull;
Procedure TestForStatementFull1; Procedure TestForStatementFull1;
Procedure TestForStatementCompact; Procedure TestForStatementCompact;
Procedure TestForStatement2loops2inits;
Procedure TestForInStatement; Procedure TestForInStatement;
Procedure TestWhileStatement; Procedure TestWhileStatement;
Procedure TestDoWhileStatement; Procedure TestDoWhileStatement;
@ -751,7 +752,7 @@ end;
TTestStatementWriter TTestStatementWriter
---------------------------------------------------------------------} ---------------------------------------------------------------------}
Procedure TTestStatementWriter.TestAssignment(Const Msg: String; procedure TTestStatementWriter.TestAssignment(const Msg: String;
AClass: TJSAssignStatementClass; Result: String; ACompact: Boolean); AClass: TJSAssignStatementClass; Result: String; ACompact: Boolean);
Var Var
U : TJSAssignStatement; U : TJSAssignStatement;
@ -762,7 +763,7 @@ begin
AssertWrite(Msg,Result,U); AssertWrite(Msg,Result,U);
end; end;
Function TTestStatementWriter.CreateAssignment(AClass: TJSAssignStatementClass function TTestStatementWriter.CreateAssignment(AClass: TJSAssignStatementClass
): TJSAssignStatement; ): TJSAssignStatement;
begin begin
if AClass=Nil then if AClass=Nil then
@ -785,37 +786,37 @@ begin
Result.B:=CreateAssignment(nil); Result.B:=CreateAssignment(nil);
end; end;
Procedure TTestStatementWriter.TestEmptyStatement; procedure TTestStatementWriter.TestEmptyStatement;
begin begin
AssertWrite('Empty statement','',TJSEmptyStatement.Create(0,0)); AssertWrite('Empty statement','',TJSEmptyStatement.Create(0,0));
end; end;
Procedure TTestStatementWriter.TestEmptyStatementComment; procedure TTestStatementWriter.TestEmptyStatementComment;
begin begin
Writer.Options:=[woEmptyStatementAsComment,woUseUTF8]; Writer.Options:=[woEmptyStatementAsComment,woUseUTF8];
AssertWrite('Empty statement as comment','/* Empty statement */',TJSEmptyStatement.Create(0,0)); AssertWrite('Empty statement as comment','/* Empty statement */',TJSEmptyStatement.Create(0,0));
end; end;
Procedure TTestStatementWriter.TestEmptyStatementBlock; procedure TTestStatementWriter.TestEmptyStatementBlock;
begin begin
AssertWrite('Empty statement block','{'+sLineBreak+'}',TJSEmptyBlockStatement.Create(0,0)); AssertWrite('Empty statement block','{'+sLineBreak+'}',TJSEmptyBlockStatement.Create(0,0));
end; end;
Procedure TTestStatementWriter.TestEmptyStatementBlockIndent; procedure TTestStatementWriter.TestEmptyStatementBlockIndent;
begin begin
Writer.IndentSize:=2; Writer.IndentSize:=2;
Writer.Indent; Writer.Indent;
AssertWrite('Empty statement block',' {'+sLineBreak+' }',TJSEmptyBlockStatement.Create(0,0)); AssertWrite('Empty statement block',' {'+sLineBreak+' }',TJSEmptyBlockStatement.Create(0,0));
end; end;
Procedure TTestStatementWriter.TestEmptyStatementBlockCompact; procedure TTestStatementWriter.TestEmptyStatementBlockCompact;
begin begin
Writer.Options:=[woCompact,woUseUTF8]; Writer.Options:=[woCompact,woUseUTF8];
AssertWrite('Empty statement block','{}',TJSEmptyBlockStatement.Create(0,0)); AssertWrite('Empty statement block','{}',TJSEmptyBlockStatement.Create(0,0));
end; end;
Procedure TTestStatementWriter.TestVarDeclaration; procedure TTestStatementWriter.TestVarDeclaration;
Var Var
V : TJSVarDeclaration; V : TJSVarDeclaration;
@ -825,7 +826,7 @@ begin
AssertWrite('simple var','a',V); AssertWrite('simple var','a',V);
end; end;
Procedure TTestStatementWriter.TestVarDeclarationInit; procedure TTestStatementWriter.TestVarDeclarationInit;
Var Var
V : TJSVarDeclaration; V : TJSVarDeclaration;
begin begin
@ -835,7 +836,7 @@ begin
AssertWrite('simple var, init ','a = 1',V); AssertWrite('simple var, init ','a = 1',V);
end; end;
Procedure TTestStatementWriter.TestVarListDeclaration; procedure TTestStatementWriter.TestVarListDeclaration;
Var Var
B,L : TJSVariableDeclarationList; B,L : TJSVariableDeclarationList;
V : TJSVarDeclaration; V : TJSVarDeclaration;
@ -854,7 +855,7 @@ begin
AssertWrite('simple var list ','a, b = 1',L); AssertWrite('simple var list ','a, b = 1',L);
end; end;
Procedure TTestStatementWriter.TestVarListDeclarationInit; procedure TTestStatementWriter.TestVarListDeclarationInit;
Var Var
B,L : TJSVariableDeclarationList; B,L : TJSVariableDeclarationList;
V : TJSVarDeclaration; V : TJSVarDeclaration;
@ -873,7 +874,7 @@ begin
AssertWrite('simple var list ','a, b',L); AssertWrite('simple var list ','a, b',L);
end; end;
Procedure TTestStatementWriter.TestVarDeclarationStatement; procedure TTestStatementWriter.TestVarDeclarationStatement;
Var Var
S : TJSVariableStatement; S : TJSVariableStatement;
@ -886,7 +887,7 @@ begin
AssertWrite('simple var','var a',S); AssertWrite('simple var','var a',S);
end; end;
Procedure TTestStatementWriter.TestVarListDeclarationStatement; procedure TTestStatementWriter.TestVarListDeclarationStatement;
Var Var
S : TJSVariableStatement; S : TJSVariableStatement;
@ -903,7 +904,7 @@ begin
AssertWrite('simple var','var a',S); AssertWrite('simple var','var a',S);
end; end;
Procedure TTestStatementWriter.TestVarListDeclarationStatement2Vars; procedure TTestStatementWriter.TestVarListDeclarationStatement2Vars;
Var Var
S : TJSVariableStatement; S : TJSVariableStatement;
V : TJSVarDeclaration; V : TJSVarDeclaration;
@ -924,7 +925,7 @@ begin
AssertWrite('simple 2 vars','var a, b',S); AssertWrite('simple 2 vars','var a, b',S);
end; end;
Procedure TTestStatementWriter.TestReturnStatement; procedure TTestStatementWriter.TestReturnStatement;
Var Var
S : TJSReturnStatement; S : TJSReturnStatement;
@ -934,7 +935,7 @@ begin
AssertWrite('simple return','return a',S); AssertWrite('simple return','return a',S);
end; end;
Procedure TTestStatementWriter.TestLabeledStatement; procedure TTestStatementWriter.TestLabeledStatement;
Var Var
LS : TJSLabeledStatement; LS : TJSLabeledStatement;
S : TJSReturnStatement; S : TJSReturnStatement;
@ -949,7 +950,7 @@ begin
AssertWrite('simple return','loc:'+sLineBreak+'return a',LS); AssertWrite('simple return','loc:'+sLineBreak+'return a',LS);
end; end;
Procedure TTestStatementWriter.TestLabeledStatementCompact; procedure TTestStatementWriter.TestLabeledStatementCompact;
Var Var
LS : TJSLabeledStatement; LS : TJSLabeledStatement;
S : TJSReturnStatement; S : TJSReturnStatement;
@ -965,7 +966,7 @@ begin
AssertWrite('simple return','loc: return a',LS); AssertWrite('simple return','loc: return a',LS);
end; end;
Procedure TTestStatementWriter.TestContinueStatement; procedure TTestStatementWriter.TestContinueStatement;
Var Var
S : TJSContinueStatement; S : TJSContinueStatement;
@ -975,7 +976,7 @@ begin
AssertWrite('simple continue','continue',S); AssertWrite('simple continue','continue',S);
end; end;
Procedure TTestStatementWriter.TestContinueTargetStatement; procedure TTestStatementWriter.TestContinueTargetStatement;
Var Var
S : TJSContinueStatement; S : TJSContinueStatement;
@ -986,7 +987,7 @@ begin
AssertWrite('continue a','continue a',S); AssertWrite('continue a','continue a',S);
end; end;
Procedure TTestStatementWriter.TestBreakStatement; procedure TTestStatementWriter.TestBreakStatement;
Var Var
S : TJSBreakStatement; S : TJSBreakStatement;
@ -996,7 +997,7 @@ begin
AssertWrite('simple break','break',S); AssertWrite('simple break','break',S);
end; end;
Procedure TTestStatementWriter.TestBreakTargetStatement; procedure TTestStatementWriter.TestBreakTargetStatement;
Var Var
S : TJSBreakStatement; S : TJSBreakStatement;
@ -1006,127 +1007,127 @@ begin
AssertWrite('simple break a','break a',S); AssertWrite('simple break a','break a',S);
end; end;
Procedure TTestStatementWriter.TestAssignmentStatementSimple; procedure TTestStatementWriter.TestAssignmentStatementSimple;
begin begin
TestAssignment('Simple assignment',TJSSimpleAssignStatement,'a = b',False); TestAssignment('Simple assignment',TJSSimpleAssignStatement,'a = b',False);
end; end;
Procedure TTestStatementWriter.TestAssignmentStatementSimpleCompact; procedure TTestStatementWriter.TestAssignmentStatementSimpleCompact;
begin begin
TestAssignment('Simple assignment',TJSSimpleAssignStatement,'a=b',True); TestAssignment('Simple assignment',TJSSimpleAssignStatement,'a=b',True);
end; end;
Procedure TTestStatementWriter.TestAssignmentStatementAdd; procedure TTestStatementWriter.TestAssignmentStatementAdd;
begin begin
TestAssignment('Add assignment',TJSAddEqAssignStatement,'a += b',False); TestAssignment('Add assignment',TJSAddEqAssignStatement,'a += b',False);
end; end;
Procedure TTestStatementWriter.TestAssignmentStatementAddCompact; procedure TTestStatementWriter.TestAssignmentStatementAddCompact;
begin begin
TestAssignment('Add assignment',TJSAddEqAssignStatement,'a+=b',True); TestAssignment('Add assignment',TJSAddEqAssignStatement,'a+=b',True);
end; end;
Procedure TTestStatementWriter.TestAssignmentStatementSubtract; procedure TTestStatementWriter.TestAssignmentStatementSubtract;
begin begin
TestAssignment('Subtract assignment',TJSSubEqAssignStatement,'a -= b',False); TestAssignment('Subtract assignment',TJSSubEqAssignStatement,'a -= b',False);
end; end;
Procedure TTestStatementWriter.TestAssignmentStatementSubtractCompact; procedure TTestStatementWriter.TestAssignmentStatementSubtractCompact;
begin begin
TestAssignment('Subtract assignment',TJSSubEqAssignStatement,'a-=b',True); TestAssignment('Subtract assignment',TJSSubEqAssignStatement,'a-=b',True);
end; end;
Procedure TTestStatementWriter.TestAssignmentStatementMultiply; procedure TTestStatementWriter.TestAssignmentStatementMultiply;
begin begin
TestAssignment('Multiply assignment',TJSMulEqAssignStatement,'a *= b',False); TestAssignment('Multiply assignment',TJSMulEqAssignStatement,'a *= b',False);
end; end;
Procedure TTestStatementWriter.TestAssignmentStatementMultiplyCompact; procedure TTestStatementWriter.TestAssignmentStatementMultiplyCompact;
begin begin
TestAssignment('Multiply assignment',TJSMulEqAssignStatement,'a*=b',True); TestAssignment('Multiply assignment',TJSMulEqAssignStatement,'a*=b',True);
end; end;
Procedure TTestStatementWriter.TestAssignmentStatementDivide; procedure TTestStatementWriter.TestAssignmentStatementDivide;
begin begin
TestAssignment('Divide assignment',TJSDivEqAssignStatement,'a /= b',False); TestAssignment('Divide assignment',TJSDivEqAssignStatement,'a /= b',False);
end; end;
Procedure TTestStatementWriter.TestAssignmentStatementDivideCompact; procedure TTestStatementWriter.TestAssignmentStatementDivideCompact;
begin begin
TestAssignment('Divide assignment',TJSDivEqAssignStatement,'a/=b',True); TestAssignment('Divide assignment',TJSDivEqAssignStatement,'a/=b',True);
end; end;
Procedure TTestStatementWriter.TestAssignmentStatementShift; procedure TTestStatementWriter.TestAssignmentStatementShift;
begin begin
TestAssignment('Shift assignment',TJSLShiftEqAssignStatement,'a <<= b',False); TestAssignment('Shift assignment',TJSLShiftEqAssignStatement,'a <<= b',False);
end; end;
Procedure TTestStatementWriter.TestAssignmentStatementShiftCompact; procedure TTestStatementWriter.TestAssignmentStatementShiftCompact;
begin begin
TestAssignment('Shift assignment',TJSLShiftEqAssignStatement,'a<<=b',True); TestAssignment('Shift assignment',TJSLShiftEqAssignStatement,'a<<=b',True);
end; end;
Procedure TTestStatementWriter.TestAssignmentStatementRShift; procedure TTestStatementWriter.TestAssignmentStatementRShift;
begin begin
TestAssignment('RShift assignment',TJSRShiftEqAssignStatement,'a >>= b',False); TestAssignment('RShift assignment',TJSRShiftEqAssignStatement,'a >>= b',False);
end; end;
Procedure TTestStatementWriter.TestAssignmentStatementRShiftCompact; procedure TTestStatementWriter.TestAssignmentStatementRShiftCompact;
begin begin
TestAssignment('RShift assignment',TJSRShiftEqAssignStatement,'a>>=b',True); TestAssignment('RShift assignment',TJSRShiftEqAssignStatement,'a>>=b',True);
end; end;
Procedure TTestStatementWriter.TestAssignmentStatementURShift; procedure TTestStatementWriter.TestAssignmentStatementURShift;
begin begin
TestAssignment('URShift assignment',TJSURShiftEqAssignStatement,'a >>>= b',False); TestAssignment('URShift assignment',TJSURShiftEqAssignStatement,'a >>>= b',False);
end; end;
Procedure TTestStatementWriter.TestAssignmentStatementURShiftCompact; procedure TTestStatementWriter.TestAssignmentStatementURShiftCompact;
begin begin
TestAssignment('URShift assignment',TJSURShiftEqAssignStatement,'a>>>=b',True); TestAssignment('URShift assignment',TJSURShiftEqAssignStatement,'a>>>=b',True);
end; end;
Procedure TTestStatementWriter.TestAssignmentStatementMod; procedure TTestStatementWriter.TestAssignmentStatementMod;
begin begin
TestAssignment('Mod assignment',TJSModEqAssignStatement,'a %= b',False); TestAssignment('Mod assignment',TJSModEqAssignStatement,'a %= b',False);
end; end;
Procedure TTestStatementWriter.TestAssignmentStatementModCompact; procedure TTestStatementWriter.TestAssignmentStatementModCompact;
begin begin
TestAssignment('Mod assignment',TJSModEqAssignStatement,'a%=b',True); TestAssignment('Mod assignment',TJSModEqAssignStatement,'a%=b',True);
end; end;
Procedure TTestStatementWriter.TestAssignmentStatementBinaryOr; procedure TTestStatementWriter.TestAssignmentStatementBinaryOr;
begin begin
TestAssignment('Binary or assignment',TJSOrEqAssignStatement,'a |= b',False); TestAssignment('Binary or assignment',TJSOrEqAssignStatement,'a |= b',False);
end; end;
Procedure TTestStatementWriter.TestAssignmentStatementBinaryOrCompact; procedure TTestStatementWriter.TestAssignmentStatementBinaryOrCompact;
begin begin
TestAssignment('Binary or assignment',TJSOrEqAssignStatement,'a |= b',False); TestAssignment('Binary or assignment',TJSOrEqAssignStatement,'a |= b',False);
end; end;
Procedure TTestStatementWriter.TestAssignmentStatementBinaryXOr; procedure TTestStatementWriter.TestAssignmentStatementBinaryXOr;
begin begin
TestAssignment('Binary xor assignment',TJSXOrEqAssignStatement,'a ^= b',False); TestAssignment('Binary xor assignment',TJSXOrEqAssignStatement,'a ^= b',False);
end; end;
Procedure TTestStatementWriter.TestAssignmentStatementBinaryXOrCompact; procedure TTestStatementWriter.TestAssignmentStatementBinaryXOrCompact;
begin begin
TestAssignment('Binary xor assignment',TJSXOrEqAssignStatement,'a^=b',True); TestAssignment('Binary xor assignment',TJSXOrEqAssignStatement,'a^=b',True);
end; end;
Procedure TTestStatementWriter.TestAssignmentStatementBinaryAnd; procedure TTestStatementWriter.TestAssignmentStatementBinaryAnd;
begin begin
TestAssignment('Binary and assignment',TJSAndEqAssignStatement,'a &= b',False); TestAssignment('Binary and assignment',TJSAndEqAssignStatement,'a &= b',False);
end; end;
Procedure TTestStatementWriter.TestAssignmentStatementBinaryAndCompact; procedure TTestStatementWriter.TestAssignmentStatementBinaryAndCompact;
begin begin
TestAssignment('Binary and assignment',TJSAndEqAssignStatement,'a&=b',True); TestAssignment('Binary and assignment',TJSAndEqAssignStatement,'a&=b',True);
end; end;
Procedure TTestStatementWriter.TestForStatementEmpty; procedure TTestStatementWriter.TestForStatementEmpty;
Var Var
S : TJSForStatement; S : TJSForStatement;
@ -1136,7 +1137,7 @@ begin
AssertWrite('neverending for','for (; ; ) {'+sLineBreak+'}',S); AssertWrite('neverending for','for (; ; ) {'+sLineBreak+'}',S);
end; end;
Procedure TTestStatementWriter.TestForStatementFull; procedure TTestStatementWriter.TestForStatementFull;
Var Var
S : TJSForStatement; S : TJSForStatement;
@ -1189,7 +1190,7 @@ begin
+'}',S); +'}',S);
end; end;
Procedure TTestStatementWriter.TestForStatementCompact; procedure TTestStatementWriter.TestForStatementCompact;
Var Var
S : TJSForStatement; S : TJSForStatement;
UPP : TJSUnaryPostPlusPlusExpression; UPP : TJSUnaryPostPlusPlusExpression;
@ -1214,7 +1215,72 @@ begin
AssertWrite('for i:=0 to 9','for (i=0; i<10; i++) {}',S); AssertWrite('for i:=0 to 9','for (i=0; i<10; i++) {}',S);
end; end;
Procedure TTestStatementWriter.TestForInStatement; procedure TTestStatementWriter.TestForStatement2loops2inits;
var
L: TJSStatementList;
function CreateIdent(aName: string): TJSPrimaryExpressionIdent;
begin
Result:=TJSPrimaryExpressionIdent.Create(0,0);
Result.Name:=TJSString(aName);
end;
function CreateNumber(i: TJSNumber): TJSLiteral;
begin
Result:=TJSLiteral.Create(0,0);
Result.Value.AsNumber:=i;
end;
function CreateAssignSt(LHS, Expr: TJSElement): TJSSimpleAssignStatement;
begin
Result:=TJSSimpleAssignStatement.Create(0,0);
Result.LHS:=LHS;
Result.Expr:=Expr;
end;
function CreateFor(LoopVar, LoopEndVar: string; StartExpr, EndExpr: TJSElement;
Up: boolean; Target: string): TJSForStatement;
var
V: TJSVariableStatement;
C: TJSCommaExpression;
begin
Result:=TJSForStatement.Create(0,0);
V:=TJSVariableStatement.Create(0,0);
Result.Init:=V;
C:=TJSCommaExpression.Create(0,0);
V.A:=C;
C.A:=CreateAssignSt(CreateIdent(LoopVar),StartExpr);
C.B:=CreateAssignSt(CreateIdent(LoopEndVar),EndExpr);
if Up then
Result.Cond:=TJSRelationalExpressionLE.Create(0,0)
else
Result.Cond:=TJSRelationalExpressionGE.Create(0,0);
TJSRelationalExpression(Result.Cond).A:=CreateIdent(LoopVar);
TJSRelationalExpression(Result.Cond).B:=CreateIdent(LoopEndVar);
if Up then
Result.Incr:=TJSUnaryPostPlusPlusExpression.Create(0,0)
else
Result.Incr:=TJSUnaryPostMinusMinusExpression.Create(0,0);
TJSUnaryExpression(Result.Incr).A:=CreateIdent(LoopVar);
Result.Body:=CreateAssignSt(CreateIdent(Target),CreateIdent(LoopVar));
end;
begin
L:=TJSStatementList.Create(0,0);
L.A:=CreateFor('$loop1','$loopend2',CreateNumber(3),CreateNumber(5),true,'$mod.i');
L.B:=CreateFor('$loop3','$loopend4',CreateNumber(10),CreateNumber(7),false,'$mod.i');
AssertWrite('for i:=3 to 5 do ; for i:=10 downto 7 do ;',
'{'+LineEnding
+'for (var $loop1 = 3, $loopend2 = 5; $loop1 <= $loopend2; $loop1++) $mod.i = $loop1;'+LineEnding
+'for (var $loop3 = 10, $loopend4 = 7; $loop3 >= $loopend4; $loop3--) $mod.i = $loop3;'+LineEnding
+'}'
,L);
end;
procedure TTestStatementWriter.TestForInStatement;
Var Var
S : TJSForInStatement; S : TJSForInStatement;
@ -1227,7 +1293,7 @@ begin
AssertWrite('for a in b','for (a in b) {'+sLineBreak+'}',S); AssertWrite('for a in b','for (a in b) {'+sLineBreak+'}',S);
end; end;
Procedure TTestStatementWriter.TestWhileStatement; procedure TTestStatementWriter.TestWhileStatement;
Var Var
S : TJSWhileStatement; S : TJSWhileStatement;
@ -1238,7 +1304,7 @@ begin
AssertWrite('while a ','while (a) {'+sLineBreak+'}',S); AssertWrite('while a ','while (a) {'+sLineBreak+'}',S);
end; end;
Procedure TTestStatementWriter.TestDoWhileStatement; procedure TTestStatementWriter.TestDoWhileStatement;
Var Var
S : TJSDoWhileStatement; S : TJSDoWhileStatement;
@ -1250,7 +1316,7 @@ begin
AssertWrite('do while a ','do {'+sLineBreak+'} while (a)',S); AssertWrite('do while a ','do {'+sLineBreak+'} while (a)',S);
end; end;
Procedure TTestStatementWriter.TestSwitchStatementEmpty; procedure TTestStatementWriter.TestSwitchStatementEmpty;
Var Var
S : TJSSwitchStatement; S : TJSSwitchStatement;
@ -1260,7 +1326,7 @@ begin
AssertWrite('switch ','switch (a) {'+sLineBreak+'}',S); AssertWrite('switch ','switch (a) {'+sLineBreak+'}',S);
end; end;
Procedure TTestStatementWriter.TestSwitchStatementEmptyCompact; procedure TTestStatementWriter.TestSwitchStatementEmptyCompact;
Var Var
S : TJSSwitchStatement; S : TJSSwitchStatement;
@ -1272,7 +1338,7 @@ begin
AssertWrite('switch ','switch (a) {}',S); AssertWrite('switch ','switch (a) {}',S);
end; end;
Procedure TTestStatementWriter.TestSwitchStatementOneElement; procedure TTestStatementWriter.TestSwitchStatementOneElement;
Var Var
S : TJSSwitchStatement; S : TJSSwitchStatement;
@ -1287,7 +1353,7 @@ begin
AssertWrite('switch ','switch (a) {'+sLineBreak+'case c:'+sLineBreak+'{'+sLineBreak+'}'+sLineBreak+'}',S); AssertWrite('switch ','switch (a) {'+sLineBreak+'case c:'+sLineBreak+'{'+sLineBreak+'}'+sLineBreak+'}',S);
end; end;
Procedure TTestStatementWriter.TestSwitchStatementOneElementCompact; procedure TTestStatementWriter.TestSwitchStatementOneElementCompact;
Var Var
S : TJSSwitchStatement; S : TJSSwitchStatement;
C : TJSCaseElement; C : TJSCaseElement;
@ -1301,7 +1367,7 @@ begin
AssertWrite('switch ','switch (a) {case c: {}}',S); AssertWrite('switch ','switch (a) {case c: {}}',S);
end; end;
Procedure TTestStatementWriter.TestSwitchStatementTwoElements; procedure TTestStatementWriter.TestSwitchStatementTwoElements;
Var Var
S : TJSSwitchStatement; S : TJSSwitchStatement;
C : TJSCaseElement; C : TJSCaseElement;
@ -1318,7 +1384,7 @@ begin
AssertWrite('switch ','switch (a) {'+sLineBreak+'case c:'+sLineBreak+'{'+sLineBreak+'}'+sLineBreak+'case d:'+sLineBreak+'{'+sLineBreak+'}'+sLineBreak+'}',S); AssertWrite('switch ','switch (a) {'+sLineBreak+'case c:'+sLineBreak+'{'+sLineBreak+'}'+sLineBreak+'case d:'+sLineBreak+'{'+sLineBreak+'}'+sLineBreak+'}',S);
end; end;
Procedure TTestStatementWriter.TestSwitchStatementTwoElementsCompact; procedure TTestStatementWriter.TestSwitchStatementTwoElementsCompact;
Var Var
S : TJSSwitchStatement; S : TJSSwitchStatement;
@ -1336,7 +1402,7 @@ begin
AssertWrite('switch ','switch (a) {case c: {} case d: {}}',S); AssertWrite('switch ','switch (a) {case c: {} case d: {}}',S);
end; end;
Procedure TTestStatementWriter.TestSwitchStatementTwoElementsDefault; procedure TTestStatementWriter.TestSwitchStatementTwoElementsDefault;
Var Var
S : TJSSwitchStatement; S : TJSSwitchStatement;
C : TJSCaseElement; C : TJSCaseElement;
@ -1355,7 +1421,7 @@ begin
AssertWrite('switch ','switch (a) {'+sLineBreak+'case c:'+sLineBreak+'{'+sLineBreak+'}'+sLineBreak+'case d:'+sLineBreak+'{'+sLineBreak+'}'+sLineBreak+'default:'+sLineBreak+'{'+sLineBreak+'}'+sLineBreak+'}',S); AssertWrite('switch ','switch (a) {'+sLineBreak+'case c:'+sLineBreak+'{'+sLineBreak+'}'+sLineBreak+'case d:'+sLineBreak+'{'+sLineBreak+'}'+sLineBreak+'default:'+sLineBreak+'{'+sLineBreak+'}'+sLineBreak+'}',S);
end; end;
Procedure TTestStatementWriter.TestSwitchStatementTwoElementsDefaultCompact; procedure TTestStatementWriter.TestSwitchStatementTwoElementsDefaultCompact;
Var Var
S : TJSSwitchStatement; S : TJSSwitchStatement;
C : TJSCaseElement; C : TJSCaseElement;
@ -1375,7 +1441,7 @@ begin
AssertWrite('switch ','switch (a) {case c: {} case d: {} default: {}}',S); AssertWrite('switch ','switch (a) {case c: {} case d: {} default: {}}',S);
end; end;
Procedure TTestStatementWriter.TestSwitchStatementTwoElementsOneEmpty; procedure TTestStatementWriter.TestSwitchStatementTwoElementsOneEmpty;
Var Var
S : TJSSwitchStatement; S : TJSSwitchStatement;
C : TJSCaseElement; C : TJSCaseElement;
@ -1402,7 +1468,7 @@ begin
+'}',S); +'}',S);
end; end;
Procedure TTestStatementWriter.TestSwitchStatementTwoElementsOneEmptyCompact; procedure TTestStatementWriter.TestSwitchStatementTwoElementsOneEmptyCompact;
Var Var
S : TJSSwitchStatement; S : TJSSwitchStatement;
C : TJSCaseElement; C : TJSCaseElement;
@ -1421,7 +1487,7 @@ begin
AssertWrite('switch ','switch (a) {case c: case d: {} default: {}}',S); AssertWrite('switch ','switch (a) {case c: case d: {} default: {}}',S);
end; end;
Procedure TTestStatementWriter.TestIfThen; procedure TTestStatementWriter.TestIfThen;
Var Var
S : TJSIfStatement; S : TJSIfStatement;
@ -1433,7 +1499,7 @@ begin
AssertWrite('if then','if (a) {'+sLineBreak+'}',S); AssertWrite('if then','if (a) {'+sLineBreak+'}',S);
end; end;
Procedure TTestStatementWriter.TestIfThenElse; procedure TTestStatementWriter.TestIfThenElse;
Var Var
S : TJSIfStatement; S : TJSIfStatement;
@ -1449,7 +1515,7 @@ begin
+'}',S); +'}',S);
end; end;
Procedure TTestStatementWriter.TestStatementListEmpty; procedure TTestStatementWriter.TestStatementListEmpty;
Var Var
S : TJSStatementList; S : TJSStatementList;
@ -1459,7 +1525,7 @@ begin
AssertWrite('Statement list','{'+sLineBreak+'}',S); AssertWrite('Statement list','{'+sLineBreak+'}',S);
end; end;
Procedure TTestStatementWriter.TestStatementListEmptyCompact; procedure TTestStatementWriter.TestStatementListEmptyCompact;
Var Var
S : TJSStatementList; S : TJSStatementList;
@ -1469,7 +1535,7 @@ begin
AssertWrite('Statement list','{}',S); AssertWrite('Statement list','{}',S);
end; end;
Procedure TTestStatementWriter.TestStatementListOneStatement; procedure TTestStatementWriter.TestStatementListOneStatement;
Var Var
S : TJSStatementList; S : TJSStatementList;
begin begin
@ -1482,7 +1548,7 @@ begin
+'}',S); +'}',S);
end; end;
Procedure TTestStatementWriter.TestStatementListOneStatementCompact; procedure TTestStatementWriter.TestStatementListOneStatementCompact;
Var Var
S : TJSStatementList; S : TJSStatementList;
@ -1494,7 +1560,7 @@ begin
AssertWrite('Statement list','{a=b}',S); AssertWrite('Statement list','{a=b}',S);
end; end;
Procedure TTestStatementWriter.TestStatementListTwoStatements; procedure TTestStatementWriter.TestStatementListTwoStatements;
Var Var
S : TJSStatementList; S : TJSStatementList;
@ -1510,7 +1576,7 @@ begin
+'}',S); +'}',S);
end; end;
Procedure TTestStatementWriter.TestStatementListTwoStatementsCompact; procedure TTestStatementWriter.TestStatementListTwoStatementsCompact;
Var Var
S : TJSStatementList; S : TJSStatementList;
@ -1537,7 +1603,7 @@ begin
+'}',S); +'}',S);
end; end;
Procedure TTestStatementWriter.TestEmptyFunctionDef; procedure TTestStatementWriter.TestEmptyFunctionDef;
Var Var
FD : TJSFunctionDeclarationStatement; FD : TJSFunctionDeclarationStatement;
@ -1551,7 +1617,7 @@ begin
+'}',FD); +'}',FD);
end; end;
Procedure TTestStatementWriter.TestEmptyFunctionDefCompact; procedure TTestStatementWriter.TestEmptyFunctionDefCompact;
Var Var
FD : TJSFunctionDeclarationStatement; FD : TJSFunctionDeclarationStatement;
@ -1564,7 +1630,7 @@ begin
AssertWrite('Empty function, compact','function a() {}',FD); AssertWrite('Empty function, compact','function a() {}',FD);
end; end;
Procedure TTestStatementWriter.TestFunctionDefParams; procedure TTestStatementWriter.TestFunctionDefParams;
Var Var
FD : TJSFunctionDeclarationStatement; FD : TJSFunctionDeclarationStatement;
@ -1582,7 +1648,7 @@ begin
+'}',FD); +'}',FD);
end; end;
Procedure TTestStatementWriter.TestFunctionDefParamsCompact; procedure TTestStatementWriter.TestFunctionDefParamsCompact;
Var Var
FD : TJSFunctionDeclarationStatement; FD : TJSFunctionDeclarationStatement;
@ -1598,7 +1664,7 @@ begin
AssertWrite('Empty function, 3 params, compact','function a(b,c,d) {}',FD); AssertWrite('Empty function, 3 params, compact','function a(b,c,d) {}',FD);
end; end;
Procedure TTestStatementWriter.TestFunctionDefBody1; procedure TTestStatementWriter.TestFunctionDefBody1;
Var Var
FD : TJSFunctionDeclarationStatement; FD : TJSFunctionDeclarationStatement;
@ -1620,7 +1686,7 @@ begin
+'}',FD); +'}',FD);
end; end;
Procedure TTestStatementWriter.TestFunctionDefBody1Compact; procedure TTestStatementWriter.TestFunctionDefBody1Compact;
Var Var
FD : TJSFunctionDeclarationStatement; FD : TJSFunctionDeclarationStatement;
R : TJSReturnStatement; R : TJSReturnStatement;
@ -1638,7 +1704,7 @@ begin
AssertWrite('1 statement, compact','function a() {return 0; }',FD); AssertWrite('1 statement, compact','function a() {return 0; }',FD);
end; end;
Procedure TTestStatementWriter.TestFunctionDefBody2; procedure TTestStatementWriter.TestFunctionDefBody2;
Var Var
FD : TJSFunctionDeclarationStatement; FD : TJSFunctionDeclarationStatement;
R : TJSReturnStatement; R : TJSReturnStatement;
@ -1673,7 +1739,7 @@ begin
+'}',FD); +'}',FD);
end; end;
Procedure TTestStatementWriter.TestFunctionDefBody2Compact; procedure TTestStatementWriter.TestFunctionDefBody2Compact;
Var Var
FD : TJSFunctionDeclarationStatement; FD : TJSFunctionDeclarationStatement;
R : TJSReturnStatement; R : TJSReturnStatement;
@ -1704,7 +1770,7 @@ begin
AssertWrite('Function, 2 statements, compact','function a(b) {b=b*10; return b}',FD); AssertWrite('Function, 2 statements, compact','function a(b) {b=b*10; return b}',FD);
end; end;
Procedure TTestStatementWriter.TestTryCatch; procedure TTestStatementWriter.TestTryCatch;
Var Var
T : TJSTryCatchStatement; T : TJSTryCatchStatement;
@ -1734,7 +1800,7 @@ begin
+'}',T); +'}',T);
end; end;
Procedure TTestStatementWriter.TestTryCatchCompact; procedure TTestStatementWriter.TestTryCatchCompact;
Var Var
T : TJSTryCatchStatement; T : TJSTryCatchStatement;
A : TJSAssignStatement; A : TJSAssignStatement;
@ -1759,7 +1825,7 @@ begin
AssertWrite('Try catch compact','try {b=b*10} catch (e) {b=1}',T); AssertWrite('Try catch compact','try {b=b*10} catch (e) {b=1}',T);
end; end;
Procedure TTestStatementWriter.TestTryFinally; procedure TTestStatementWriter.TestTryFinally;
Var Var
T : TJSTryFinallyStatement; T : TJSTryFinallyStatement;
@ -1789,7 +1855,7 @@ begin
+'}',T); +'}',T);
end; end;
Procedure TTestStatementWriter.TestTryFinallyCompact; procedure TTestStatementWriter.TestTryFinallyCompact;
Var Var
T : TJSTryFinallyStatement; T : TJSTryFinallyStatement;
@ -1815,7 +1881,7 @@ begin
AssertWrite('Try finally compact','try {b=b*10} finally {b=1}',T); AssertWrite('Try finally compact','try {b=b*10} finally {b=1}',T);
end; end;
Procedure TTestStatementWriter.TestTryCatchFinally; procedure TTestStatementWriter.TestTryCatchFinally;
Var Var
T : TJSTryCatchFinallyStatement; T : TJSTryCatchFinallyStatement;
A : TJSAssignStatement; A : TJSAssignStatement;
@ -1849,7 +1915,7 @@ begin
+' b = 1'+sLineBreak+'}',T); +' b = 1'+sLineBreak+'}',T);
end; end;
Procedure TTestStatementWriter.TestTryCatchFinallyCompact; procedure TTestStatementWriter.TestTryCatchFinallyCompact;
Var Var
T : TJSTryCatchFinallyStatement; T : TJSTryCatchFinallyStatement;
A : TJSAssignStatement; A : TJSAssignStatement;
@ -1878,7 +1944,7 @@ begin
AssertWrite('Try finally ','try {b=b*10} catch (e) {b=10} finally {b=1}',T); AssertWrite('Try finally ','try {b=b*10} catch (e) {b=10} finally {b=1}',T);
end; end;
Procedure TTestStatementWriter.TestWith; procedure TTestStatementWriter.TestWith;
Var Var
T : TJSWithStatement; T : TJSWithStatement;
A : TJSAssignStatement; A : TJSAssignStatement;
@ -1899,7 +1965,7 @@ begin
AssertWrite('With statement ','with (e)'+slineBreak+' b = b * 10',T); AssertWrite('With statement ','with (e)'+slineBreak+' b = b * 10',T);
end; end;
Procedure TTestStatementWriter.TestWithCompact; procedure TTestStatementWriter.TestWithCompact;
Var Var
T : TJSWithStatement; T : TJSWithStatement;
A : TJSAssignStatement; A : TJSAssignStatement;
@ -1920,7 +1986,7 @@ begin
AssertWrite('With statement ','with (e) b=b*10',T); AssertWrite('With statement ','with (e) b=b*10',T);
end; end;
Procedure TTestStatementWriter.TestSourceElements; procedure TTestStatementWriter.TestSourceElements;
Var Var
T : TJSSourceElements; T : TJSSourceElements;
A : TJSAssignStatement; A : TJSAssignStatement;
@ -1947,7 +2013,7 @@ begin
AssertWrite('Statement lists ','b = b * 10;'+sLineBreak+'c = c * 2;'+sLineBreak,T); AssertWrite('Statement lists ','b = b * 10;'+sLineBreak+'c = c * 2;'+sLineBreak,T);
end; end;
Procedure TTestStatementWriter.TestSourceElementsCompact; procedure TTestStatementWriter.TestSourceElementsCompact;
Var Var
T : TJSSourceElements; T : TJSSourceElements;
A : TJSAssignStatement; A : TJSAssignStatement;
@ -2466,18 +2532,36 @@ Procedure TTestJSWriter.AssertResult(Const Msg, Result: String);
Var Var
S : AnsiString; S : AnsiString;
p: Integer;
begin begin
S:=FTextWriter.AsAnsistring; S:=FTextWriter.AsAnsistring;
AssertEquals(Msg,Result,S); if S=Result then exit;
p:=1;
while (p<=length(S)) and (p<=length(Result)) and (S[p]=Result[p]) do inc(p);
if p>length(S) then
AssertEquals(Msg+' (actual too short)',Result,S)
else if p>length(Result) then
AssertEquals(Msg+' (actual too long)',Result,S)
else
AssertEquals(Msg+' (diff at '+IntToStr(p)+' "'+S[p]+'")',Result,S);
end; end;
Procedure TTestJSWriter.AssertResult(Const Msg: string; Result: UnicodeString); Procedure TTestJSWriter.AssertResult(Const Msg: string; Result: UnicodeString);
Var Var
S : UnicodeString; S : UnicodeString;
p: Integer;
begin begin
S:=FTextWriter.AsUnicodeString; S:=FTextWriter.AsUnicodeString;
AssertEquals(Msg,String(Result),String(S)); if S=Result then exit;
p:=1;
while (p<=length(S)) and (p<=length(Result)) and (S[p]=Result[p]) do inc(p);
if p>length(S) then
AssertEquals(Msg+' (actual too short)',String(Result),String(S))
else if p>length(Result) then
AssertEquals(Msg+' (actual too long)',String(Result),String(S))
else
AssertEquals(Msg+' (diff at '+IntToStr(p)+' "'+String(S[p])+'")',String(Result),String(S));
end; end;
Procedure TTestJSWriter.AssertWrite(Const Msg, Result: String; Procedure TTestJSWriter.AssertWrite(Const Msg, Result: String;