package jnpf.elnFormula;
|
|
import org.junit.Test;
|
|
import static org.junit.Assert.assertEquals;
|
import static org.junit.Assert.assertNotNull;
|
import static org.junit.Assert.assertTrue;
|
import static org.junit.Assert.fail;
|
|
public class FormulaParserTest {
|
|
private final FormulaParser parser = new FormulaParser();
|
|
@Test
|
public void parsesSupportedFormulaLanguage() {
|
assertNode("12.50");
|
assertNode("\"result\\ntext\"");
|
assertNode("true");
|
assertNode("false");
|
assertNode("null");
|
assertNode("sample_weight_a1");
|
assertNode("(sample_weight_a1 * factor_b2) / volume_c3");
|
assertNode("IF(IS_BLANK(observed_a1), fallback_b2, observed_a1)");
|
assertNode("!(result_a1 >= 1.5 && result_a1 < 10) || result_a1 == 0");
|
assertNode("-2 ^ -2 + 5 % 2");
|
}
|
|
@Test
|
public void buildsOwnImmutableAstWithSourceOffsets() {
|
FormulaAst.Node node = parser.parse("sample_a1 + 2");
|
|
assertTrue(node instanceof FormulaAst.Binary);
|
assertEquals(0, node.getStartOffset());
|
assertEquals(13, node.getEndOffset());
|
FormulaAst.Binary binary = (FormulaAst.Binary) node;
|
assertEquals("+", binary.getOperator());
|
assertTrue(binary.getLeft() instanceof FormulaAst.Parameter);
|
assertTrue(binary.getRight() instanceof FormulaAst.Literal);
|
}
|
|
@Test
|
public void rejectsCapabilitiesOutsideControlledDsl() {
|
assertRejected("java.lang.Runtime.getRuntime()", "LEXICAL_ERROR");
|
assertRejected("x[0]", "LEXICAL_ERROR");
|
assertRejected("x = 1", "LEXICAL_ERROR");
|
assertRejected("x; 1", "LEXICAL_ERROR");
|
assertRejected("new", "FORBIDDEN_IDENTIFIER");
|
assertRejected("method()", "SYNTAX_ERROR");
|
assertRejected("1 // comment", "SYNTAX_ERROR");
|
assertRejected("1 /* comment */", "SYNTAX_ERROR");
|
}
|
|
@Test
|
public void rejectsMalformedTokensAndSyntaxWithoutLeakingParserErrors() {
|
assertRejected("\"unterminated", "LEXICAL_ERROR");
|
assertRejected("IF(1, 2", "SYNTAX_ERROR");
|
assertRejected("1 +", "SYNTAX_ERROR");
|
assertRejected("", "SYNTAX_ERROR");
|
}
|
|
@Test
|
public void enforcesExpressionIdentifierTokenAndDepthLimits() {
|
assertRejected(repeat('a', 8193), "EXPRESSION_TOO_LONG");
|
assertRejected(repeat('a', 81), "IDENTIFIER_TOO_LONG");
|
assertRejected(repeat('A', 81) + "()", "IDENTIFIER_TOO_LONG");
|
|
StringBuilder tokens = new StringBuilder();
|
for (int i = 0; i < 2049; i++) {
|
if (i > 0) {
|
tokens.append('+');
|
}
|
tokens.append('1');
|
}
|
assertRejected(tokens.toString(), "TOKEN_LIMIT_EXCEEDED");
|
|
assertNode(nested(63));
|
assertRejected(nested(65), "AST_DEPTH_EXCEEDED");
|
}
|
|
@Test
|
public void exposesStableDiagnosticLocation() {
|
try {
|
parser.parse("sample_a1 + @");
|
fail("expected parse rejection");
|
} catch (FormulaParser.ParseException ex) {
|
assertEquals("LEXICAL_ERROR", ex.getCode());
|
assertEquals(12, ex.getStartOffset());
|
assertEquals(13, ex.getEndOffset());
|
assertNotNull(ex.getMessage());
|
assertTrue(!ex.getMessage().contains("org.antlr"));
|
}
|
}
|
|
@Test
|
public void exposesUtf16OffsetsAfterSupplementaryCharacters() {
|
FormulaAst.Binary logical = (FormulaAst.Binary) parser.parse(
|
"\"😀\" == \"x\" && missing_a1");
|
FormulaAst.Parameter parameter = (FormulaAst.Parameter) logical.getRight();
|
assertEquals(15, parameter.getStartOffset());
|
assertEquals(25, parameter.getEndOffset());
|
|
try {
|
parser.parse("\"😀\" == \"x\" &&");
|
fail("expected syntax rejection");
|
} catch (FormulaParser.ParseException ex) {
|
assertEquals("SYNTAX_ERROR", ex.getCode());
|
assertEquals(14, ex.getStartOffset());
|
assertEquals(14, ex.getEndOffset());
|
}
|
}
|
|
private void assertNode(String expression) {
|
assertTrue(parser.parse(expression) instanceof FormulaAst.Node);
|
}
|
|
private void assertRejected(String expression, String code) {
|
try {
|
parser.parse(expression);
|
fail("expected " + code + " for: " + expression);
|
} catch (FormulaParser.ParseException ex) {
|
assertEquals(code, ex.getCode());
|
}
|
}
|
|
private static String nested(int depth) {
|
StringBuilder value = new StringBuilder(depth * 2 + 1);
|
for (int i = 0; i < depth; i++) {
|
value.append('(');
|
}
|
value.append('1');
|
for (int i = 0; i < depth; i++) {
|
value.append(')');
|
}
|
return value.toString();
|
}
|
|
private static String repeat(char value, int count) {
|
StringBuilder result = new StringBuilder(count);
|
for (int i = 0; i < count; i++) {
|
result.append(value);
|
}
|
return result.toString();
|
}
|
}
|
