/*
* Copyright 2010 The Closure Compiler Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.javascript.jscomp.jsonml;
import com.google.javascript.jscomp.jsonml.JsonML;
import com.google.javascript.jscomp.jsonml.JsonMLUtil;
import com.google.javascript.jscomp.jsonml.TagAttr;
import com.google.javascript.jscomp.jsonml.TagType;
import com.google.javascript.jscomp.jsonml.Validator;
import junit.framework.TestCase;
/**
* Tests validation of particular JsonML elements.
*
* @author dhans@google.com (Daniel Hans)
*/
public class JsonMLValidationTest extends TestCase {
// Used for correct statements - error message should be null
private void testValidation(String jsonml) throws Exception {
JsonML jsonMLRoot = JsonMLUtil.parseString(jsonml);
String msg = Validator.validate(jsonMLRoot);
if (msg != null) {
String errorMsg = String.format(
"Validation error for %s.\n Received: %s\n", jsonml, msg);
}
}
private void testValidation(String jsonml, String expected)
throws Exception {
JsonML jsonMLRoot = JsonMLUtil.parseString(jsonml);
String msg = Validator.validate(jsonMLRoot);
if (!msg.equals(expected)) {
String errorMsg = String.format(
"Validation error for %s.\n Received: %s\n Expected: %s\n",
jsonml, msg, expected);
assertEquals(errorMsg, expected, msg);
}
}
private void testNotEnoughChildrenValidation(String jsonml, TagType type,
int expected, int actual) throws Exception {
testValidation(jsonml,
String.format(Validator.NOT_ENOUGH_CHILDREN_FMT,
type, expected, actual));
}
private void testTooManyChildrenValidation(String jsonml, TagType type,
int expected, int actual) throws Exception {
testValidation(jsonml,
String.format(Validator.TOO_MANY_CHILDREN_FMT,
type, expected, actual));
}
private void testWrongChildTypeValidation(String jsonml, TagType type,
TagType expected, TagType actual, int index) throws Exception {
testWrongChildTypeValidation(jsonml, type, new TagType[] { expected },
actual, index);
}
private void testWrongChildTypeValidation(String jsonml, TagType type,
TagType[] expected, TagType actual, int index) throws Exception {
testValidation(jsonml,
String.format(Validator.WRONG_CHILD_TYPE_FMT,
index, type, Validator.printList(expected), actual));
}
private void testMissingArgument(String jsonml, TagAttr attr, TagType type)
throws Exception {
testValidation(jsonml,
String.format(Validator.MISSING_ARGUMENT, attr, type));
}
public void testAssignExpr() throws Exception {
// correct statement
testValidation("" +
"['AssignExpr',{'op':'='}," +
"['IdExpr',{'name':'x'}]," +
"['LiteralExpr',{'type':'number','value':1}]]");
// wrong number of children
testNotEnoughChildrenValidation("" +
"['AssignExpr',{'op':'='}," +
"['IdExpr',{'name':'x'}]]",
TagType.AssignExpr, 2, 1);
testTooManyChildrenValidation("" +
"['AssignExpr',{'op':'='}," +
"['IdExpr',{'name':'x'}]," +
"['IdExpr',{'name':'y'}]," +
"['IdExpr',{'name':'z'}]]",
TagType.AssignExpr, 2, 3);
// missing attribute
testMissingArgument("" +
"['AssignExpr',{}," +
"['IdExpr',{'name':'x'}]," +
"['LiteralExpr',{'type':'number','value':1}]]",
TagAttr.OP, TagType.AssignExpr);
}
public void testBinaryExpr() throws Exception {
// correct statement
testValidation("" +
"['BinaryExpr',{'op':'+'}," +
"['IdExpr',{'name':'a'}]," +
"['LiteralExpr',{'type':'number','value':1}]]");
// wrong number of children
testNotEnoughChildrenValidation("" +
"['BinaryExpr',{'op':'+'}," +
"['IdExpr',{'name':'a'}]]",
TagType.BinaryExpr, 2, 1);
testTooManyChildrenValidation("" +
"['BinaryExpr',{'op':'&&'}," +
"['IdExpr',{'name':'a'}]," +
"['IdExpr',{'name':'b'}]," +
"['IdExpr',{'name':'c'}]]",
TagType.BinaryExpr, 2, 3);
// missing attribute
testMissingArgument("" +
"['BinaryExpr',{}," +
"['IdExpr',{'name':'a'}]," +
"['LiteralExpr',{'type':'number','value':1}]]",
TagAttr.OP, TagType.BinaryExpr);
}
public void testCaseValidation() throws Exception {
// correct statement
testValidation("" +
"['Case',{}," +
"['IdExpr',{'name':'a'}]]");
testValidation("" +
"['Case',{}," +
"['IdExpr',{'name':'a'}]," +
"['CallExpr',{}," +
"['IdExpr',{'name':'foo'}]]]");
// wrong number of children
testNotEnoughChildrenValidation("" +
"['Case',{}]",
TagType.Case, 1, 0);
}
public void testCatchValidation() throws Exception {
// correct statement
testValidation("" +
"['CatchClause',{}," +
"['IdPatt',{'name':'e'}]," +
"['BlockStmt',{}]]");
// wrong number of children
testNotEnoughChildrenValidation("" +
"['CatchClause',{}," +
"['IdPatt',{'name':'e'}]]",
TagType.CatchClause, 2, 1);
// wrong children types
testWrongChildTypeValidation("" +
"['CatchClause',{}," +
"['IdExpr',{'name':'e'}]," +
"['BlockStmt',{}]]",
TagType.CatchClause, TagType.IdPatt, TagType.IdExpr, 0);
}
public void testConditionalExprValidation() throws Exception {
// correct statement
testValidation("" +
"['ConditionalExpr',{}," +
"['BinaryExpr',{'op':'=='}," +
"['IdExpr',{'name':'x'}]," +
"['LiteralExpr',{'type':'number','value':0}]]," +
"['LiteralExpr',{'type':'number','value':0}]," +
"['LiteralExpr',{'type':'number','value':1}]]");
// wrong number of children
testNotEnoughChildrenValidation("" +
"['ConditionalExpr',{}," +
"['BinaryExpr',{'op':'=='}," +
"['IdExpr',{'name':'x'}]," +
"['LiteralExpr',{'type':'number','value':0}]]]",
TagType.ConditionalExpr, 3, 1);
testNotEnoughChildrenValidation("" +
"['ConditionalExpr',{}," +
"['BinaryExpr',{'op':'=='}," +
"['IdExpr',{'name':'x'}]," +
"['LiteralExpr',{'type':'number','value':0}]]," +
"['LiteralExpr',{'type':'number','value':1}]]",
TagType.ConditionalExpr, 3, 2);
}
public void testCountExprValidation() throws Exception {
// correct statement
testValidation("" +
"['CountExpr',{'isPrefix':false,'op':'++'}," +
"['IdExpr',{'name':'x'}]]");
// wrong number of children
testTooManyChildrenValidation("" +
"['CountExpr',{'isPrefix':false,'op':'++'}," +
"['IdExpr',{'name':'x'}]," +
"['IdExpr',{'name':'y'}]]",
TagType.CountExpr, 1, 2);
// missing attribute
testMissingArgument("" +
"['CountExpr',{'op':'++'}," +
"['IdExpr',{'name':'x'}]]",
TagAttr.IS_PREFIX, TagType.CountExpr);
testMissingArgument("" +
"['CountExpr',{'isPrefix':false}," +
"['IdExpr',{'name':'x'}]]",
TagAttr.OP, TagType.CountExpr);
}
public void testDataProp() throws Exception {
// correct statement
testValidation("" +
"['DataProp',{'name':'x'}," +
"['LiteralExpr',{'type':'number','value':1}]]");
// wrong number of children
testNotEnoughChildrenValidation("" +
"['DataProp',{'name':'x'}]",
TagType.DataProp, 1, 0);
// missing argument
testMissingArgument("" +
"['DataProp', {}," +
"['LiteralExpr',{'type':'number','value':1}]]",
TagAttr.NAME, TagType.DataProp);
}
public void testDeleteExpr() throws Exception {
// correct statement
testValidation("" +
"['DeleteExpr',{}," +
"['IdExpr',{'name':'x'}]]");
//wrong number of children
testNotEnoughChildrenValidation("" +
"['DeleteExpr',{}]",
TagType.DeleteExpr, 1, 0);
testTooManyChildrenValidation("" +
"['DeleteExpr',{}," +
"['IdExpr',{'name':'x'}]," +
"['IdExpr',{'name':'y'}]]",
TagType.DeleteExpr, 1, 2);
}
public void testDoWhileStmtValidation() throws Exception {
// correct statement
testValidation("" +
"['DoWhileStmt',{}," +
"['BlockStmt',{}]," +
"['LiteralExpr',{'type':'boolean','value':true}]]");
// wrong number of children
testNotEnoughChildrenValidation("" +
"['DoWhileStmt',{}]",
TagType.DoWhileStmt, 2, 0);
testTooManyChildrenValidation("" +
"['DoWhileStmt',{}," +
"['BlockStmt',{}]," +
"['BlockStmt',{}]," +
"['LiteralExpr',{'type':'boolean','value':true}]]",
TagType.DoWhileStmt, 2, 3);
}
public void testEmptyStmtValidation() throws Exception {
// correct statement
testValidation("" +
"['EmptyStmt',{}]");
// wrong number of children
testTooManyChildrenValidation("" +
"['EmptyStmt',{}," +
"['BlockStmt',{}]]",
TagType.EmptyStmt, 0, 1);
}
public void testForInStmtValidation() throws Exception {
// correct statement
testValidation("" +
"['ForInStmt',{}," +
"['IdExpr',{'name':'x'}]," +
"['ObjectExpr',{}]," +
"['BlockStmt',{}]]");
// wrong number of children
testNotEnoughChildrenValidation("" +
"['ForInStmt',{}," +
"['IdExpr',{'name':'x'}]," +
"['ObjectExpr',{}]],",
TagType.ForInStmt, 3, 2);
testTooManyChildrenValidation("" +
"['ForInStmt',{}," +
"['IdExpr',{'name':'x'}]," +
"['ObjectExpr',{}]," +
"['BlockStmt',{}]," +
"['BlockStmt',{}]]",
TagType.ForInStmt, 3, 4);
}
public void testForStmtValidation() throws Exception {
// correct statement
testValidation("" +
"['ForStmt',{}," +
"['AssignExpr',{'op':'='}," +
"['IdExpr',{'name':'i'}]," +
"['LiteralExpr',{'type':'number','value':0}]]," +
"['BinaryExpr',{'op':'<'}," +
"['IdExpr',{'name':'i'}]," +
"['IdExpr',{'name':'n'}]]," +
"['CountExpr',{'isPrefix':true,'op':'++'}," +
"['IdExpr',{'name':'i'}]]," +
"['BlockStmt',{}]]");
// wrong number of children
testNotEnoughChildrenValidation("" +
"['ForStmt',{}," +
"['BinaryExpr',{'op':'<'}," +
"['IdExpr',{'name':'i'}]," +
"['IdExpr',{'name':'n'}]]," +
"['CountExpr',{'isPrefix':true,'op':'++'}," +
"['IdExpr',{'name':'i'}]]," +
"['BlockStmt',{}]]",
TagType.ForStmt, 4, 3);
testTooManyChildrenValidation("" +
"['ForStmt',{}," +
"['AssignExpr',{'op':'='}," +
"['IdExpr',{'name':'i'}]," +
"['LiteralExpr',{'type':'number','value':0}]]," +
"['BinaryExpr',{'op':'<'}," +
"['IdExpr',{'name':'i'}]," +
"['IdExpr',{'name':'n'}]]," +
"['CountExpr',{'isPrefix':true,'op':'++'}," +
"['IdExpr',{'name':'i'}]]," +
"['BlockStmt',{}]," +
"['BlockStmt',{}]]",
TagType.ForStmt, 4, 5);
}
public void testFunctionDeclValidation() throws Exception {
// correct statement
testValidation("" +
"['FunctionDecl',{}," +
"['IdPatt',{'name':'f'}]," +
"['ParamDecl',{}]]");
testValidation("" +
"['FunctionDecl',{}," +
"['IdPatt',{'name':'f'}]," +
"['ParamDecl',{}]," +
"['IdExpr',{'name':'foo'}]]");
// wrong number of children
testNotEnoughChildrenValidation("" +
"['FunctionDecl',{}," +
"['IdPatt',{'name':'f'}]]",
TagType.FunctionDecl, 2, 1);
// function name not specified
testWrongChildTypeValidation("" +
"['FunctionDecl',{}," +
"['Empty', {}]," +
"['ParamDecl',{}]]",
TagType.FunctionDecl, TagType.IdPatt, TagType.Empty, 0);
// list of formal arguments not specified
testWrongChildTypeValidation("" +
"['FunctionDecl',{}," +
"['IdPatt',{'name':'f'}]," +
"['Empty',{}]]",
TagType.FunctionDecl, TagType.ParamDecl, TagType.Empty, 1);
}
public void testFunctionExprValidation() throws Exception {
// correct statement
testValidation("" +
"['FunctionExpr',{}," +
"['IdPatt',{'name':'f'}]," +
"['ParamDecl',{}]]");
testValidation("" +
"['FunctionExpr',{}," +
"['IdPatt',{'name':'f'}]," +
"['ParamDecl',{}]," +
"['IdExpr',{'name':'foo'}]]");
testValidation("" +
"['FunctionExpr',{}," +
"['Empty', {}]," +
"['ParamDecl',{}]]");
}
public void testIdExprValidation() throws Exception {
// correct statement
testValidation("" +
"['IdExpr',{'name':'x'}]");
// wrong number of children
testTooManyChildrenValidation("" +
"['IdExpr',{'name':'x'}," +
"['BlockStmt',{}]]",
TagType.IdExpr, 0, 1);
// missing name argument
testMissingArgument("" +
"['IdExpr', {}]",
TagAttr.NAME, TagType.IdExpr);
}
public void testIdPattValidation() throws Exception {
// correct statement
testValidation("" +
"['IdPatt',{'name':'x'}]");
// wrong number of children
testTooManyChildrenValidation("" +
"['IdPatt',{'name':'x'}," +
"['BlockStmt',{}]]",
TagType.IdPatt, 0, 1);
// missing name argument
testMissingArgument("" +
"['IdPatt', {}]",
TagAttr.NAME, TagType.IdPatt);
}
public void testIfStmtValidation() throws Exception {
// correct statement
testValidation("" +
"['IfStmt',{}," +
"['LiteralExpr',{'type':'boolean','value':true}]," +
"['BlockStmt',{}]," +
"['EmptyStmt',{}]]");
testValidation("" +
"['IfStmt',{}," +
"['LiteralExpr',{'type':'boolean','value':true}]," +
"['BlockStmt',{}]," +
"['BlockStmt',{}]]");
// wrong number of children
testNotEnoughChildrenValidation("" +
"['IfStmt',{}," +
"['LiteralExpr',{'type':'boolean','value':true}]," +
"['BlockStmt',{}]]",
TagType.IfStmt, 3, 2);
}
public void testInvokeExprValidation() throws Exception {
// correct statement
testValidation("" +
"['InvokeExpr',{'op':'.'}," +
"['IdExpr',{'name':'x'}]," +
"['LiteralExpr',{'type':'string','value':'foo'}]]");
// wrong number of children
testNotEnoughChildrenValidation("" +
"['InvokeExpr',{'op':'[]'}," +
"['IdExpr',{'name':'x'}]]",
TagType.InvokeExpr, 2, 1);
// missing attribute
testMissingArgument("" +
"['InvokeExpr',{}," +
"['IdExpr',{'name':'x'}]," +
"['LiteralExpr',{'type':'string','value':'foo'}]]",
TagAttr.OP, TagType.InvokeExpr);
}
public void testJmpStmtValidation() throws Exception {
// correct statement
testValidation("" +
"['BreakStmt',{}]");
testValidation("" +
"['BreakStmt',{'label':'s'}]");
testValidation("" +
"['ContinueStmt',{}]");
testValidation("" +
"['ContinueStmt',{'label':'s'}]");
// wrong number of children
testTooManyChildrenValidation("" +
"['BreakStmt',{}," +
"['IdExpr',{'name':'s'}]]",
TagType.BreakStmt, 0, 1);
testTooManyChildrenValidation("" +
"['ContinueStmt',{}," +
"['IdExpr',{'name':'s'}]]",
TagType.ContinueStmt, 0, 1);
}
public void testLabelledStmtValidation() throws Exception {
// correct statement
testValidation("" +
"['LabelledStmt',{'label':'s'}," +
"['IdExpr',{'name':'x'}]]");
// wrong number of children
testNotEnoughChildrenValidation("" +
"['LabelledStmt',{'label':'s'}]",
TagType.LabelledStmt, 1, 0);
testTooManyChildrenValidation("" +
"['LabelledStmt',{'label':'s'}," +
"['IdExpr',{'name':'x'}]," +
"['IdExpr',{'name':'y'}]]",
TagType.LabelledStmt, 1, 2);
// missing attribute
testMissingArgument("" +
"['LabelledStmt',{}," +
"['IdExpr',{'name':'x'}]]",
TagAttr.LABEL, TagType.LabelledStmt);
}
public void testLiteralExprValidation() throws Exception {
// correct statement
testValidation("" +
"['LiteralExpr',{'type':'string','value':'x'}]");
testValidation("" +
"['LiteralExpr',{'type':'boolean','value':'true'}]");
testValidation("" +
"['LiteralExpr',{'type':'number','value':'1.0'}]");
// wrong number of children
testTooManyChildrenValidation("" +
"['LiteralExpr',{'type':'number','value':'1.0'}," +
"['BlockStmt',{}]]",
TagType.LiteralExpr, 0, 1);
// missing attribute
testMissingArgument("" +
"['LiteralExpr',{'type':'string'}]",
TagAttr.VALUE, TagType.LiteralExpr);
testMissingArgument("" +
"['LiteralExpr',{'value':'1.0'}]",
TagAttr.TYPE, TagType.LiteralExpr);
}
public void testLogicalExprValidation() throws Exception {
// correct statement
testValidation("" +
"['LogicalAndExpr',{}," +
"['IdExpr',{'name':'a'}]," +
"['IdExpr',{'name':'b'}]]");
testValidation("" +
"['LogicalOrExpr',{}," +
"['IdExpr',{'name':'a'}]," +
"['IdExpr',{'name':'b'}]]");
// wrong number of children
testTooManyChildrenValidation("" +
"['LogicalAndExpr',{}," +
"['IdExpr',{'name':'a'}]," +
"['IdExpr',{'name':'b'}]," +
"['IdExpr',{'name':'c'}]]",
TagType.LogicalAndExpr, 2, 3);
testNotEnoughChildrenValidation("" +
"['LogicalAndExpr',{}," +
"['IdExpr',{'name':'a'}]]",
TagType.LogicalAndExpr, 2, 1);
}
public void testNewExprValidation() throws Exception {
// correct statement
testValidation("" +
"['NewExpr',{}," +
"['IdExpr',{'name':'A'}]," +
"['IdExpr',{'name':'x'}]]");
// wrong number of children
testNotEnoughChildrenValidation("" +
"['NewExpr',{}]",
TagType.NewExpr, 1, 0);
}
public void testObjectExprValidation() throws Exception {
// correct statement
testValidation("" +
"['ObjectExpr',{}]");
testValidation("" +
"['ObjectExpr',{}," +
"['DataProp',{'name':'x'}," +
"['LiteralExpr',{'type':'number','value':1}]]," +
"['DataProp',{'name':'y'}," +
"['LiteralExpr',{'type':'number','value':2}]]]");
// wrong types of children
TagType[] tags =
{TagType.DataProp, TagType.GetterProp, TagType.SetterProp };
testWrongChildTypeValidation("" +
"['ObjectExpr',{}," +
"['DataProp',{'name':'x'}," +
"['LiteralExpr',{'type':'number','value':1}]]," +
"['IdExpr',{'name':'y'}]]",
TagType.ObjectExpr, tags, TagType.IdExpr, 1);
}
public void testParamDeclValidation() throws Exception {
// correct statement
testValidation("" +
"['ParamDecl',{}]");
testValidation("" +
"['ParamDecl',{}," +
"['IdPatt',{'name':'x'}]," +
"['IdPatt',{'name':'y'}]]");
// wrong types of children
testWrongChildTypeValidation("" +
"['ParamDecl',{}," +
"['IdPatt',{'name':'x'}]," +
"['IdExpr',{'name':'y'}]]",
TagType.ParamDecl, TagType.IdPatt, TagType.IdExpr, 1);
}
public void testRegExpExprValidation() throws Exception {
// correct statement
testValidation("" +
"['RegExpExpr',{'body':'abc','flags':''}]");
testValidation("" +
"['RegExpExpr',{'body':'abc','flags':'g'}]");
// wrong number of children
testTooManyChildrenValidation("" +
"['RegExpExpr',{'body':'abc','flags':'g'}," +
"['IdExpr',{'name':'a'}]]",
TagType.RegExpExpr, 0, 1);
// missing attribute
testMissingArgument("" +
"['RegExpExpr',{'body':'abc'}]",
TagAttr.FLAGS, TagType.RegExpExpr);
testMissingArgument("" +
"['RegExpExpr',{'flags':'g'}]",
TagAttr.BODY, TagType.RegExpExpr);
}
public void testReturnStmtValidation() throws Exception {
// correct statement
testValidation("" +
"['ReturnStmt',{}]");
testValidation("" +
"['ReturnStmt',{}," +
"['LiteralExpr',{'type':'number','value':1}]]");
// wrong number of children
testTooManyChildrenValidation("" +
"['ReturnStmt',{}," +
"['IdExpr',{'name':'a'}]," +
"['IdExpr',{'name':'b'}]]",
TagType.ReturnStmt, 1, 2);
}
public void testSwitchStmtValidation() throws Exception {
// correct statement
testValidation("" +
"['SwitchStmt',{}," +
"['IdExpr',{'name':'x'}]," +
"['Case',{}," +
"['LiteralExpr',{'type':'number','value':1}]," +
"['CallExpr',{}," +
"['IdExpr',{'name':'foo'}]]]," +
"['DefaultCase',{}," +
"['CallExpr',{}," +
"['IdExpr',{'name':'bar'}]]]]");
testValidation("" +
"['SwitchStmt',{}," +
"['IdExpr',{'name':'x'}]]");
// wrong number of children
testNotEnoughChildrenValidation("" +
"['SwitchStmt',{}]",
TagType.SwitchStmt, 1, 0);
// wrong types of children
testWrongChildTypeValidation("" +
"['SwitchStmt',{}," +
"['IdExpr',{'name':'x'}]," +
"['AssignExpr',{'op': '='}," +
"['LiteralExpr',{'type':'number','value':1}]," +
"['CallExpr',{}," +
"['IdExpr',{'name':'foo'}]]]," +
"['DefaultCase',{}," +
"['CallExpr',{}," +
"['IdExpr',{'name':'bar'}]]]]",
TagType.SwitchStmt,
new TagType[] { TagType.Case, TagType.DefaultCase },
TagType.AssignExpr, 1);
testWrongChildTypeValidation("" +
"['SwitchStmt',{}," +
"['IdExpr',{'name':'x'}]," +
"['DefaultCase',{}," +
"['CallExpr',{}," +
"['IdExpr',{'name':'foo'}]]]," +
"['DefaultCase',{}," +
"['CallExpr',{}," +
"['IdExpr',{'name':'bar'}]]]]",
TagType.SwitchStmt, TagType.Case, TagType.DefaultCase, 2);
}
public void testThisExprValidation() throws Exception {
// correct statement
testValidation("" +
"['ThisExpr',{}]");
// wrong number of children
testTooManyChildrenValidation("" +
"['ThisExpr',{}," +
"['IdExpr',{'name':'a'}]]",
TagType.ThisExpr, 0, 1);
}
public void testThrowStmtValidation() throws Exception {
// correct statement
testValidation("" +
"['ThrowStmt',{}," +
"['IdExpr',{'name':'e'}]]");
// wrong number of children
testTooManyChildrenValidation("" +
"['ThrowStmt',{}," +
"['IdExpr',{'name':'a'}]," +
"['IdExpr',{'name':'b'}]]",
TagType.ThrowStmt, 1, 2);
}
public void testTryStmtValidation() throws Exception {
// correct statement
testValidation("" +
"['TryStmt',{}," +
"['BlockStmt',{}]," +
"['CatchClause',{}," +
"['IdPatt',{'name':'e'}]," +
"['BlockStmt',{}]]]");
testValidation("" +
"['TryStmt',{}," +
"['BlockStmt',{}]," +
"['CatchClause',{}," +
"['IdPatt',{'name':'e'}]," +
"['BlockStmt',{}]]," +
"['BlockStmt',{}]]");
// wrong number of children
testNotEnoughChildrenValidation("" +
"['TryStmt',{}," +
"['CatchClause',{}," +
"['IdPatt',{'name':'e'}]," +
"['BlockStmt',{}]]]",
TagType.TryStmt, 2, 1);
testTooManyChildrenValidation("" +
"['TryStmt',{}," +
"['BlockStmt',{}]," +
"['CatchClause',{}," +
"['IdPatt',{'name':'e'}]," +
"['BlockStmt',{}]]," +
"['BlockStmt',{}]," +
"['BlockStmt',{}]]",
TagType.TryStmt, 3, 4);
// wrong type of children
testWrongChildTypeValidation("" +
"['TryStmt',{}," +
"['BlockStmt',{}]," +
"['BlockStmt',{}," +
"['IdPatt',{'name':'e'}]," +
"['BlockStmt',{}]]," +
"['BlockStmt',{}]]",
TagType.TryStmt,
new TagType[] { TagType.CatchClause, TagType.Empty },
TagType.BlockStmt, 1);
testWrongChildTypeValidation("" +
"['TryStmt',{}," +
"['BlockStmt',{}]," +
"['CatchClause',{}," +
"['IdPatt',{'name':'e'}]," +
"['BlockStmt',{}]]," +
"['IdExpr',{'name': 'x'}]]",
TagType.TryStmt, TagType.BlockStmt, TagType.IdExpr, 2);
}
public void testUnaryExprValidation() throws Exception {
// correct statement
testValidation("" +
"['UnaryExpr',{'op':'-'}," +
"['IdExpr',{'name':'x'}]]");
testValidation("" +
"['UnaryExpr',{'op':'!'}," +
"['CallExpr',{}," +
"['IdExpr',{'name':'f'}]," +
"['IdExpr',{'name':'x'}]]]");
// wrong number of children
testNotEnoughChildrenValidation("" +
"['UnaryExpr',{'op':'-'}]",
TagType.UnaryExpr, 1, 0);
testTooManyChildrenValidation("" +
"['UnaryExpr',{'op':'+'}," +
"['IdExpr',{'name':'x'}]," +
"['IdExpr',{'name':'y'}]]",
TagType.UnaryExpr, 1, 2);
// missing attribute
testMissingArgument("" +
"['UnaryExpr',{}," +
"['IdExpr',{'name':'x'}]]",
TagAttr.OP, TagType.UnaryExpr);
}
public void testVarDeclValidation() throws Exception {
// correct statement
testValidation("" +
"['VarDecl',{}," +
"['IdPatt',{'name':'x'}]]");
testValidation("" +
"['VarDecl',{}," +
"['InitPatt',{}," +
"['IdPatt',{'name':'x'}]," +
"['LiteralExpr',{'type':'number','value':0}]]]");
testValidation("" +
"['VarDecl',{}," +
"['InitPatt',{}," +
"['IdPatt',{'name':'x'}]," +
"['LiteralExpr',{'type':'number','value':0}]]," +
"['IdPatt',{'name':'y'}]]");
// wrong number of children
testNotEnoughChildrenValidation("" +
"['VarDecl',{}]",
TagType.VarDecl, 1, 0);
// wrong type of children
testWrongChildTypeValidation("" +
"['VarDecl',{}," +
"['InitPatt',{}," +
"['IdPatt',{'name':'x'}]," +
"['LiteralExpr',{'type':'number','value':0}]]," +
"['IdExpr',{'name':'y'}]," +
"['IdPatt',{'name':'z'}]]",
TagType.VarDecl,
new TagType[] { TagType.InitPatt, TagType.IdPatt },
TagType.IdExpr, 1);
}
public void testWhileStmtValidation() throws Exception {
// correct statement
testValidation("" +
"['WhileStmt',{}," +
"['LiteralExpr',{'type':'boolean','value':true}]," +
"['BlockStmt',{}]]");
testValidation("" +
"['WhileStmt',{}," +
"['LiteralExpr',{'type':'boolean','value':true}]," +
"['IdExpr',{'name':'x'}]]");
// wrong number of children
testNotEnoughChildrenValidation("" +
"['WhileStmt',{}," +
"['BlockStmt',{}]]",
TagType.WhileStmt, 2, 1);
testTooManyChildrenValidation("" +
"['WhileStmt',{}," +
"['LiteralExpr',{'type':'boolean','value':true}]," +
"['IdExpr',{'name':'x'}]," +
"['IdExpr',{'name':'y'}]]",
TagType.WhileStmt, 2, 3);
}
public void testWithStmtValidation() throws Exception {
// correct statement
testValidation("" +
"['WithStmt',{}," +
"['IdExpr',{'name':'x'}]," +
"['BlockStmt',{}]]");
// wrong number of children
testNotEnoughChildrenValidation("" +
"['WithStmt',{}," +
"['BlockStmt',{}]]",
TagType.WithStmt, 2, 1);
testTooManyChildrenValidation("" +
"['WithStmt',{}," +
"['IdExpr',{'name':'A'}]," +
"['IdExpr',{'name':'x'}]," +
"['IdExpr',{'name':'y'}]]",
TagType.WithStmt, 2, 3);
}
}