diff --git a/core/trino-parser/pom.xml b/core/trino-parser/pom.xml
index 3a634c90264e2..f3b0a88dfe879 100644
--- a/core/trino-parser/pom.xml
+++ b/core/trino-parser/pom.xml
@@ -41,14 +41,26 @@
- io.trino
- trino-testing-services
+ org.assertj
+ assertj-core
test
- org.assertj
- assertj-core
+ org.junit.jupiter
+ junit-jupiter-api
+ test
+
+
+
+ org.junit.jupiter
+ junit-jupiter-engine
+ test
+
+
+
+ org.junit.jupiter
+ junit-jupiter-params
test
diff --git a/core/trino-parser/src/test/java/io/trino/sql/parser/TestParsingException.java b/core/trino-parser/src/test/java/io/trino/sql/parser/TestParsingException.java
index bfe625d305f70..1b04aab23008e 100644
--- a/core/trino-parser/src/test/java/io/trino/sql/parser/TestParsingException.java
+++ b/core/trino-parser/src/test/java/io/trino/sql/parser/TestParsingException.java
@@ -14,7 +14,7 @@
package io.trino.sql.parser;
import io.trino.sql.tree.NodeLocation;
-import org.testng.annotations.Test;
+import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
diff --git a/core/trino-parser/src/test/java/io/trino/sql/parser/TestSqlParser.java b/core/trino-parser/src/test/java/io/trino/sql/parser/TestSqlParser.java
index 92c3c8bf0bdc7..dc075577bda77 100644
--- a/core/trino-parser/src/test/java/io/trino/sql/parser/TestSqlParser.java
+++ b/core/trino-parser/src/test/java/io/trino/sql/parser/TestSqlParser.java
@@ -196,7 +196,8 @@
import io.trino.sql.tree.WithQuery;
import io.trino.sql.tree.ZeroOrMoreQuantifier;
import io.trino.sql.tree.ZeroOrOneQuantifier;
-import org.testng.annotations.Test;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
import java.util.ArrayList;
import java.util.List;
@@ -251,12 +252,12 @@
import static java.lang.String.format;
import static java.util.Collections.emptyList;
import static java.util.Objects.requireNonNull;
+import static java.util.concurrent.TimeUnit.SECONDS;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.testng.Assert.assertEquals;
-import static org.testng.Assert.assertFalse;
-import static org.testng.Assert.assertTrue;
-import static org.testng.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
public class TestSqlParser
{
@@ -282,7 +283,8 @@ public void testPossibleExponentialBacktracking()
createExpression("(((((((((((((((((((((((((((true)))))))))))))))))))))))))))");
}
- @Test(timeOut = 2_000)
+ @Test
+ @Timeout(value = 2, unit = SECONDS)
public void testPotentialUnboundedLookahead()
{
createExpression("(\n" +
@@ -304,13 +306,16 @@ public void testPotentialUnboundedLookahead()
@Test
public void testQualifiedName()
{
- assertEquals(QualifiedName.of("a", "b", "c", "d").toString(), "a.b.c.d");
- assertEquals(QualifiedName.of("A", "b", "C", "d").toString(), "a.b.c.d");
+ assertThat(QualifiedName.of("a", "b", "c", "d").toString())
+ .isEqualTo("a.b.c.d");
+ assertThat(QualifiedName.of("A", "b", "C", "d").toString())
+ .isEqualTo("a.b.c.d");
assertTrue(QualifiedName.of("a", "b", "c", "d").hasSuffix(QualifiedName.of("b", "c", "d")));
assertTrue(QualifiedName.of("a", "b", "c", "d").hasSuffix(QualifiedName.of("a", "b", "c", "d")));
assertFalse(QualifiedName.of("a", "b", "c", "d").hasSuffix(QualifiedName.of("a", "c", "d")));
assertFalse(QualifiedName.of("a", "b", "c", "d").hasSuffix(QualifiedName.of("z", "a", "b", "c", "d")));
- assertEquals(QualifiedName.of("a", "b", "c", "d"), QualifiedName.of("a", "b", "c", "d"));
+ assertThat(QualifiedName.of("a", "b", "c", "d"))
+ .isEqualTo(QualifiedName.of("a", "b", "c", "d"));
}
@Test
@@ -2557,7 +2562,8 @@ public void testNonReserved()
public void testBinaryLiteralToHex()
{
// note that toHexString() always outputs in upper case
- assertEquals(new BinaryLiteral("ab 01").toHexString(), "AB01");
+ assertThat(new BinaryLiteral("ab 01").toHexString())
+ .isEqualTo("AB01");
}
@Test
diff --git a/core/trino-parser/src/test/java/io/trino/sql/parser/TestSqlParserErrorHandling.java b/core/trino-parser/src/test/java/io/trino/sql/parser/TestSqlParserErrorHandling.java
index 17ded4bffe689..481de0d5f136c 100644
--- a/core/trino-parser/src/test/java/io/trino/sql/parser/TestSqlParserErrorHandling.java
+++ b/core/trino-parser/src/test/java/io/trino/sql/parser/TestSqlParserErrorHandling.java
@@ -13,146 +13,158 @@
*/
package io.trino.sql.parser;
-import org.testng.annotations.DataProvider;
-import org.testng.annotations.Test;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import java.util.stream.Stream;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.testng.Assert.assertEquals;
-import static org.testng.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
public class TestSqlParserErrorHandling
{
private static final SqlParser SQL_PARSER = new SqlParser();
private static final ParsingOptions PARSING_OPTIONS = new ParsingOptions();
- @DataProvider(name = "expressions")
- public Object[][] getExpressions()
+ private static Stream expressions()
{
- return new Object[][] {
- {"", "line 1:1: mismatched input ''. Expecting: "},
- {"1 + 1 x", "line 1:7: mismatched input 'x'. Expecting: '%', '*', '+', '-', '.', '/', 'AND', 'AT', 'OR', '[', '||', , "}};
+ return Stream.of(
+ Arguments.of("", "line 1:1: mismatched input ''. Expecting: "),
+ Arguments.of("1 + 1 x", "line 1:7: mismatched input 'x'. Expecting: '%', '*', '+', '-', '.', '/', 'AND', 'AT', 'OR', '[', '||', , "));
}
- @DataProvider(name = "statements")
- public Object[][] getStatements()
+ private static Stream statements()
{
- return new Object[][] {
- {"",
+ return Stream.of(
+ Arguments.of("",
"line 1:1: mismatched input ''. Expecting: 'ALTER', 'ANALYZE', 'CALL', 'COMMENT', 'COMMIT', 'CREATE', 'DEALLOCATE', 'DELETE', 'DENY', 'DESC', 'DESCRIBE', 'DROP', 'EXECUTE', 'EXPLAIN', 'GRANT', " +
- "'INSERT', 'MERGE', 'PREPARE', 'REFRESH', 'RESET', 'REVOKE', 'ROLLBACK', 'SET', 'SHOW', 'START', 'TRUNCATE', 'UPDATE', 'USE', "},
- {"@select",
+ "'INSERT', 'MERGE', 'PREPARE', 'REFRESH', 'RESET', 'REVOKE', 'ROLLBACK', 'SET', 'SHOW', 'START', 'TRUNCATE', 'UPDATE', 'USE', "),
+ Arguments.of("@select",
"line 1:1: mismatched input '@'. Expecting: 'ALTER', 'ANALYZE', 'CALL', 'COMMENT', 'COMMIT', 'CREATE', 'DEALLOCATE', 'DELETE', 'DENY', 'DESC', 'DESCRIBE', 'DROP', 'EXECUTE', 'EXPLAIN', 'GRANT', " +
- "'INSERT', 'MERGE', 'PREPARE', 'REFRESH', 'RESET', 'REVOKE', 'ROLLBACK', 'SET', 'SHOW', 'START', 'TRUNCATE', 'UPDATE', 'USE', "},
- {"select * from foo where @what",
- "line 1:25: mismatched input '@'. Expecting: "},
- {"select * from 'oops",
- "line 1:15: mismatched input '''. Expecting: '(', 'LATERAL', 'UNNEST', "},
- {"select *\nfrom x\nfrom",
+ "'INSERT', 'MERGE', 'PREPARE', 'REFRESH', 'RESET', 'REVOKE', 'ROLLBACK', 'SET', 'SHOW', 'START', 'TRUNCATE', 'UPDATE', 'USE', "),
+ Arguments.of("select * from foo where @what",
+ "line 1:25: mismatched input '@'. Expecting: "),
+ Arguments.of("select * from 'oops",
+ "line 1:15: mismatched input '''. Expecting: '(', 'LATERAL', 'UNNEST', "),
+ Arguments.of("select *\nfrom x\nfrom",
"line 3:1: mismatched input 'from'. Expecting: ',', '.', 'AS', 'CROSS', 'EXCEPT', 'FETCH', 'FOR', 'FULL', 'GROUP', 'HAVING', 'INNER', 'INTERSECT', 'JOIN', 'LEFT', " +
- "'LIMIT', 'MATCH_RECOGNIZE', 'NATURAL', 'OFFSET', 'ORDER', 'RIGHT', 'TABLESAMPLE', 'UNION', 'WHERE', 'WINDOW', , "},
- {"select *\nfrom x\nwhere from",
- "line 3:7: mismatched input 'from'. Expecting: "},
- {"select ",
- "line 1:8: mismatched input ''. Expecting: '*', 'ALL', 'DISTINCT', "},
- {"select * from",
- "line 1:14: mismatched input ''. Expecting: '(', 'LATERAL', 'UNNEST', "},
- {"select * from ",
- "line 1:16: mismatched input ''. Expecting: '(', 'LATERAL', 'UNNEST', "},
- {"select * from `foo`",
- "line 1:15: backquoted identifiers are not supported; use double quotes to quote identifiers"},
- {"select * from foo `bar`",
- "line 1:19: backquoted identifiers are not supported; use double quotes to quote identifiers"},
- {"select 1x from dual",
- "line 1:8: identifiers must not start with a digit; surround the identifier with double quotes"},
- {"select fuu from dual order by fuu order by fuu",
- "line 1:35: mismatched input 'order'. Expecting: '%', '*', '+', ',', '-', '.', '/', 'AND', 'ASC', 'AT', 'DESC', 'FETCH', 'LIMIT', 'NULLS', 'OFFSET', 'OR', '[', '||', , "},
- {"select fuu from dual limit 10 order by fuu",
- "line 1:31: mismatched input 'order'. Expecting: "},
- {"select CAST(12223222232535343423232435343 AS BIGINT)",
- "line 1:1: Invalid numeric literal: 12223222232535343423232435343"},
- {"select CAST(-12223222232535343423232435343 AS BIGINT)",
- "line 1:1: Invalid numeric literal: -12223222232535343423232435343"},
- {"select foo.!",
- "line 1:12: mismatched input '!'. Expecting: '*', "},
- {"select foo(,1)",
- "line 1:12: mismatched input ','. Expecting: ')', '*', 'ALL', 'DISTINCT', 'ORDER', "},
- {"select foo ( ,1)",
- "line 1:14: mismatched input ','. Expecting: ')', '*', 'ALL', 'DISTINCT', 'ORDER', "},
- {"select foo(DISTINCT)",
- "line 1:20: mismatched input ')'. Expecting: "},
- {"select foo(DISTINCT ,1)",
- "line 1:21: mismatched input ','. Expecting: "},
- {"CREATE )",
- "line 1:8: mismatched input ')'. Expecting: 'MATERIALIZED', 'OR', 'ROLE', 'SCHEMA', 'TABLE', 'VIEW'"},
- {"CREATE TABLE ) AS (VALUES 1)",
- "line 1:14: mismatched input ')'. Expecting: 'IF', "},
- {"CREATE TABLE foo ",
- "line 1:18: mismatched input ''. Expecting: '(', '.', 'AS', 'COMMENT', 'WITH'"},
- {"CREATE TABLE foo () AS (VALUES 1)",
- "line 1:19: mismatched input ')'. Expecting: 'LIKE', "},
- {"CREATE TABLE foo (*) AS (VALUES 1)",
- "line 1:19: mismatched input '*'. Expecting: 'LIKE', "},
- {"SELECT grouping(a+2) FROM (VALUES (1)) AS t (a) GROUP BY a+2",
- "line 1:18: mismatched input '+'. Expecting: ')', ',', '.'"},
- {"SELECT x() over (ROWS select) FROM t",
- "line 1:23: mismatched input 'select'. Expecting: 'BETWEEN', 'CURRENT', 'UNBOUNDED', "},
- {"SELECT X() OVER (ROWS UNBOUNDED) FROM T",
- "line 1:32: mismatched input ')'. Expecting: 'FOLLOWING', 'PRECEDING'"},
- {"SELECT a FROM x ORDER BY (SELECT b FROM t WHERE ",
- "line 1:49: mismatched input ''. Expecting: "},
- {"SELECT a FROM a AS x TABLESAMPLE x ",
- "line 1:34: mismatched input 'x'. Expecting: 'BERNOULLI', 'SYSTEM'"},
- {"SELECT a AS z FROM t GROUP BY CUBE (a), ",
- "line 1:41: mismatched input ''. Expecting: '(', 'CUBE', 'GROUPING', 'ROLLUP', "},
- {"SELECT a AS z FROM t WHERE x = 1 + ",
- "line 1:36: mismatched input ''. Expecting: "},
- {"SELECT a AS z FROM t WHERE a. ",
- "line 1:29: mismatched input '.'. Expecting: '%', '*', '+', '-', '/', 'AND', 'AT', 'EXCEPT', 'FETCH', 'GROUP', 'HAVING', 'INTERSECT', 'LIMIT', 'OFFSET', 'OR', 'ORDER', 'UNION', 'WINDOW', '||', , "},
- {"CREATE TABLE t (x bigint) COMMENT ",
- "line 1:35: mismatched input ''. Expecting: "},
- {"SELECT * FROM ( ",
- "line 1:17: mismatched input ''. Expecting: '(', 'LATERAL', 'UNNEST', , "},
- {"SELECT CAST(a AS )",
- "line 1:18: mismatched input ')'. Expecting: "},
- {"SELECT CAST(a AS decimal()",
- "line 1:26: mismatched input ')'. Expecting: , "},
- {"SELECT foo(*) filter (",
- "line 1:23: mismatched input ''. Expecting: 'WHERE'"},
- {"SELECT * FROM t t x",
+ "'LIMIT', 'MATCH_RECOGNIZE', 'NATURAL', 'OFFSET', 'ORDER', 'RIGHT', 'TABLESAMPLE', 'UNION', 'WHERE', 'WINDOW', , "),
+ Arguments.of("select *\nfrom x\nwhere from",
+ "line 3:7: mismatched input 'from'. Expecting: "),
+ Arguments.of("select ",
+ "line 1:8: mismatched input ''. Expecting: '*', 'ALL', 'DISTINCT', "),
+ Arguments.of("select * from",
+ "line 1:14: mismatched input ''. Expecting: '(', 'LATERAL', 'UNNEST', "),
+ Arguments.of("select * from ",
+ "line 1:16: mismatched input ''. Expecting: '(', 'LATERAL', 'UNNEST', "),
+ Arguments.of("select * from `foo`",
+ "line 1:15: backquoted identifiers are not supported; use double quotes to quote identifiers"),
+ Arguments.of("select * from foo `bar`",
+ "line 1:19: backquoted identifiers are not supported; use double quotes to quote identifiers"),
+ Arguments.of("select 1x from dual",
+ "line 1:8: identifiers must not start with a digit; surround the identifier with double quotes"),
+ Arguments.of("select fuu from dual order by fuu order by fuu",
+ "line 1:35: mismatched input 'order'. Expecting: '%', '*', '+', ',', '-', '.', '/', 'AND', 'ASC', 'AT', 'DESC', 'FETCH', 'LIMIT', 'NULLS', 'OFFSET', 'OR', '[', '||', , "),
+ Arguments.of("select fuu from dual limit 10 order by fuu",
+ "line 1:31: mismatched input 'order'. Expecting: "),
+ Arguments.of("select CAST(12223222232535343423232435343 AS BIGINT)",
+ "line 1:1: Invalid numeric literal: 12223222232535343423232435343"),
+ Arguments.of("select CAST(-12223222232535343423232435343 AS BIGINT)",
+ "line 1:1: Invalid numeric literal: -12223222232535343423232435343"),
+ Arguments.of("select foo.!",
+ "line 1:12: mismatched input '!'. Expecting: '*', "),
+ Arguments.of("select foo(,1)",
+ "line 1:12: mismatched input ','. Expecting: ')', '*', 'ALL', 'DISTINCT', 'ORDER', "),
+ Arguments.of("select foo ( ,1)",
+ "line 1:14: mismatched input ','. Expecting: ')', '*', 'ALL', 'DISTINCT', 'ORDER', "),
+ Arguments.of("select foo(DISTINCT)",
+ "line 1:20: mismatched input ')'. Expecting: "),
+ Arguments.of("select foo(DISTINCT ,1)",
+ "line 1:21: mismatched input ','. Expecting: "),
+ Arguments.of("CREATE )",
+ "line 1:8: mismatched input ')'. Expecting: 'MATERIALIZED', 'OR', 'ROLE', 'SCHEMA', 'TABLE', 'VIEW'"),
+ Arguments.of("CREATE TABLE ) AS (VALUES 1)",
+ "line 1:14: mismatched input ')'. Expecting: 'IF', "),
+ Arguments.of("CREATE TABLE foo ",
+ "line 1:18: mismatched input ''. Expecting: '(', '.', 'AS', 'COMMENT', 'WITH'"),
+ Arguments.of("CREATE TABLE foo () AS (VALUES 1)",
+ "line 1:19: mismatched input ')'. Expecting: 'LIKE', "),
+ Arguments.of("CREATE TABLE foo (*) AS (VALUES 1)",
+ "line 1:19: mismatched input '*'. Expecting: 'LIKE', "),
+ Arguments.of("SELECT grouping(a+2) FROM (VALUES (1)) AS t (a) GROUP BY a+2",
+ "line 1:18: mismatched input '+'. Expecting: ')', ',', '.'"),
+ Arguments.of("SELECT x() over (ROWS select) FROM t",
+ "line 1:23: mismatched input 'select'. Expecting: 'BETWEEN', 'CURRENT', 'UNBOUNDED', "),
+ Arguments.of("SELECT X() OVER (ROWS UNBOUNDED) FROM T",
+ "line 1:32: mismatched input ')'. Expecting: 'FOLLOWING', 'PRECEDING'"),
+ Arguments.of("SELECT a FROM x ORDER BY (SELECT b FROM t WHERE ",
+ "line 1:49: mismatched input ''. Expecting: "),
+ Arguments.of("SELECT a FROM a AS x TABLESAMPLE x ",
+ "line 1:34: mismatched input 'x'. Expecting: 'BERNOULLI', 'SYSTEM'"),
+ Arguments.of("SELECT a AS z FROM t GROUP BY CUBE (a), ",
+ "line 1:41: mismatched input ''. Expecting: '(', 'CUBE', 'GROUPING', 'ROLLUP', "),
+ Arguments.of("SELECT a AS z FROM t WHERE x = 1 + ",
+ "line 1:36: mismatched input ''. Expecting: "),
+ Arguments.of("SELECT a AS z FROM t WHERE a. ",
+ "line 1:29: mismatched input '.'. Expecting: '%', '*', '+', '-', '/', 'AND', 'AT', 'EXCEPT', 'FETCH', 'GROUP', 'HAVING', 'INTERSECT', 'LIMIT', 'OFFSET', 'OR', 'ORDER', 'UNION', 'WINDOW', '||', , "),
+ Arguments.of("CREATE TABLE t (x bigint) COMMENT ",
+ "line 1:35: mismatched input ''. Expecting: "),
+ Arguments.of("SELECT * FROM ( ",
+ "line 1:17: mismatched input ''. Expecting: '(', 'LATERAL', 'UNNEST', , "),
+ Arguments.of("SELECT CAST(a AS )",
+ "line 1:18: mismatched input ')'. Expecting: "),
+ Arguments.of("SELECT CAST(a AS decimal()",
+ "line 1:26: mismatched input ')'. Expecting: , "),
+ Arguments.of("SELECT foo(*) filter (",
+ "line 1:23: mismatched input ''. Expecting: 'WHERE'"),
+ Arguments.of("SELECT * FROM t t x",
"line 1:19: mismatched input 'x'. Expecting: '(', ',', 'CROSS', 'EXCEPT', 'FETCH', 'FULL', 'GROUP', 'HAVING', 'INNER', 'INTERSECT', 'JOIN', 'LEFT', 'LIMIT', " +
- "'MATCH_RECOGNIZE', 'NATURAL', 'OFFSET', 'ORDER', 'RIGHT', 'TABLESAMPLE', 'UNION', 'WHERE', 'WINDOW', "},
- {"SELECT * FROM t WHERE EXISTS (",
- "line 1:31: mismatched input ''. Expecting: "},
- {"SELECT \"\" FROM t",
- "line 1:8: Zero-length delimited identifier not allowed"},
- {"SELECT a FROM \"\"",
- "line 1:15: Zero-length delimited identifier not allowed"},
- {"SELECT a FROM \"\".t",
- "line 1:15: Zero-length delimited identifier not allowed"},
- {"SELECT a FROM \"\".s.t",
- "line 1:15: Zero-length delimited identifier not allowed"},
- {"WITH t AS (SELECT 1 SELECT t.* FROM t",
+ "'MATCH_RECOGNIZE', 'NATURAL', 'OFFSET', 'ORDER', 'RIGHT', 'TABLESAMPLE', 'UNION', 'WHERE', 'WINDOW', "),
+ Arguments.of("SELECT * FROM t WHERE EXISTS (",
+ "line 1:31: mismatched input ''. Expecting: "),
+ Arguments.of("SELECT \"\" FROM t",
+ "line 1:8: Zero-length delimited identifier not allowed"),
+ Arguments.of("SELECT a FROM \"\"",
+ "line 1:15: Zero-length delimited identifier not allowed"),
+ Arguments.of("SELECT a FROM \"\".t",
+ "line 1:15: Zero-length delimited identifier not allowed"),
+ Arguments.of("SELECT a FROM \"\".s.t",
+ "line 1:15: Zero-length delimited identifier not allowed"),
+ Arguments.of("WITH t AS (SELECT 1 SELECT t.* FROM t",
"line 1:21: mismatched input 'SELECT'. Expecting: '%', '(', ')', '*', '+', ',', '-', '.', '/', 'AND', 'AS', 'AT', 'EXCEPT', 'FETCH', 'FROM', " +
"'GROUP', 'HAVING', 'INTERSECT', 'LIMIT', 'OFFSET', 'OR', 'ORDER', 'SELECT', 'TABLE', 'UNION', 'VALUES', 'WHERE', 'WINDOW', '[', '||', , " +
- ", "},
- {"SHOW CATALOGS LIKE '%$_%' ESCAPE",
- "line 1:33: mismatched input ''. Expecting: "},
- {"SHOW SCHEMAS IN foo LIKE '%$_%' ESCAPE",
- "line 1:39: mismatched input ''. Expecting: "},
- {"SHOW FUNCTIONS LIKE '%$_%' ESCAPE",
- "line 1:34: mismatched input ''. Expecting: "},
- {"SHOW SESSION LIKE '%$_%' ESCAPE",
- "line 1:32: mismatched input ''. Expecting: "},
- {"SELECT * FROM t FOR TIMESTAMP ",
- "line 1:31: mismatched input ''. Expecting: 'AS'"},
- {"SELECT * FROM t FOR TIMESTAMP AS OF TIMESTAMP WHERE",
- "line 1:52: mismatched input ''. Expecting: "},
- {"SELECT * FROM t FOR VERSION AS OF TIMESTAMP WHERE",
- "line 1:50: mismatched input ''. Expecting: "}
- };
+ ", "),
+ Arguments.of("SHOW CATALOGS LIKE '%$_%' ESCAPE",
+ "line 1:33: mismatched input ''. Expecting: "),
+ Arguments.of("SHOW SCHEMAS IN foo LIKE '%$_%' ESCAPE",
+ "line 1:39: mismatched input ''. Expecting: "),
+ Arguments.of("SHOW FUNCTIONS LIKE '%$_%' ESCAPE",
+ "line 1:34: mismatched input ''. Expecting: "),
+ Arguments.of("SHOW SESSION LIKE '%$_%' ESCAPE",
+ "line 1:32: mismatched input ''. Expecting: "),
+ Arguments.of("SHOW CATALOGS LIKE '%$_%' ESCAPE",
+ "line 1:33: mismatched input ''. Expecting: "),
+ Arguments.of("SHOW SCHEMAS IN foo LIKE '%$_%' ESCAPE",
+ "line 1:39: mismatched input ''. Expecting: "),
+ Arguments.of("SHOW FUNCTIONS LIKE '%$_%' ESCAPE",
+ "line 1:34: mismatched input ''. Expecting: "),
+ Arguments.of("SHOW SESSION LIKE '%$_%' ESCAPE",
+ "line 1:32: mismatched input ''. Expecting: "),
+ Arguments.of("SELECT * FROM t FOR TIMESTAMP ",
+ "line 1:31: mismatched input ''. Expecting: 'AS'"),
+ Arguments.of("SELECT * FROM t FOR TIMESTAMP AS OF TIMESTAMP WHERE",
+ "line 1:52: mismatched input ''. Expecting: "),
+ Arguments.of("SELECT * FROM t FOR VERSION AS OF TIMESTAMP WHERE",
+ "line 1:50: mismatched input ''. Expecting: "));
}
- @Test(timeOut = 1000)
+ @Test
+ @Timeout(value = 1, unit = SECONDS)
public void testPossibleExponentialBacktracking()
{
testStatement("SELECT CASE WHEN " +
@@ -199,7 +211,8 @@ public void testPossibleExponentialBacktracking2()
"line 24:1: mismatched input 'GROUP'. Expecting: ')', ',', '.', 'FILTER', 'IGNORE', 'OVER', 'RESPECT', '['");
}
- @Test(dataProvider = "statements")
+ @ParameterizedTest
+ @MethodSource("statements")
public void testStatement(String sql, String error)
{
assertThatThrownBy(() -> SQL_PARSER.createStatement(sql, PARSING_OPTIONS))
@@ -207,7 +220,8 @@ public void testStatement(String sql, String error)
.hasMessage(error);
}
- @Test(dataProvider = "expressions")
+ @ParameterizedTest
+ @MethodSource("expressions")
public void testExpression(String sql, String error)
{
assertThatThrownBy(() -> SQL_PARSER.createExpression(sql, PARSING_OPTIONS))
@@ -222,32 +236,40 @@ public void testParsingExceptionPositionInfo()
.isInstanceOfSatisfying(ParsingException.class, e -> {
assertTrue(e.getMessage().startsWith("line 3:7: mismatched input 'from'"));
assertTrue(e.getErrorMessage().startsWith("mismatched input 'from'"));
- assertEquals(e.getLineNumber(), 3);
- assertEquals(e.getColumnNumber(), 7);
+ assertEquals(3, e.getLineNumber());
+ assertEquals(7, e.getColumnNumber());
});
}
- @Test(expectedExceptions = ParsingException.class, expectedExceptionsMessageRegExp = "line 1:1: expression is too large \\(stack overflow while parsing\\)")
+ @Test
public void testStackOverflowExpression()
{
- for (int size = 3000; size <= 100_000; size *= 2) {
- String expression = "x = y";
- for (int i = 1; i < size; i++) {
- expression = "(" + expression + ") OR x = y";
- }
- SQL_PARSER.createExpression(expression, new ParsingOptions());
- }
+ assertThatThrownBy(
+ () -> {
+ for (int size = 3000; size <= 100_000; size *= 2) {
+ String expression = "x = y";
+ for (int i = 1; i < size; i++) {
+ expression = "(" + expression + ") OR x = y";
+ }
+ SQL_PARSER.createExpression(expression, new ParsingOptions());
+ }
+ })
+ .hasMessageContaining("line 1:1: expression is too large (stack overflow while parsing)");
}
- @Test(expectedExceptions = ParsingException.class, expectedExceptionsMessageRegExp = "line 1:1: statement is too large \\(stack overflow while parsing\\)")
+ @Test
public void testStackOverflowStatement()
{
- for (int size = 6000; size <= 100_000; size *= 2) {
- String expression = "x = y";
- for (int i = 1; i < size; i++) {
- expression = "(" + expression + ") OR x = y";
- }
- SQL_PARSER.createStatement("SELECT " + expression, PARSING_OPTIONS);
- }
+ assertThatThrownBy(
+ () -> {
+ for (int size = 6000; size <= 100_000; size *= 2) {
+ String expression = "x = y";
+ for (int i = 1; i < size; i++) {
+ expression = "(" + expression + ") OR x = y";
+ }
+ SQL_PARSER.createStatement("SELECT " + expression, PARSING_OPTIONS);
+ }
+ })
+ .hasMessageContaining("line 1:1: statement is too large (stack overflow while parsing)");
}
}
diff --git a/core/trino-parser/src/test/java/io/trino/sql/parser/TestStatementBuilder.java b/core/trino-parser/src/test/java/io/trino/sql/parser/TestStatementBuilder.java
index ca0fba27622d2..5faca57ccf0bc 100644
--- a/core/trino-parser/src/test/java/io/trino/sql/parser/TestStatementBuilder.java
+++ b/core/trino-parser/src/test/java/io/trino/sql/parser/TestStatementBuilder.java
@@ -17,7 +17,7 @@
import io.trino.sql.SqlFormatter;
import io.trino.sql.tree.Expression;
import io.trino.sql.tree.Statement;
-import org.testng.annotations.Test;
+import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.io.UncheckedIOException;
@@ -27,8 +27,8 @@
import static io.trino.sql.testing.TreeAssertions.assertFormattedSql;
import static java.lang.String.format;
import static java.nio.charset.StandardCharsets.UTF_8;
-import static org.testng.Assert.assertEquals;
-import static org.testng.Assert.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
public class TestStatementBuilder
{
@@ -389,7 +389,7 @@ private static void assertSqlFormatter(String expression, String formatted)
{
Expression originalExpression = SQL_PARSER.createExpression(expression, new ParsingOptions());
String real = SqlFormatter.formatSql(originalExpression);
- assertEquals(real, formatted);
+ assertEquals(formatted, real);
}
private static void println(String s)
diff --git a/core/trino-parser/src/test/java/io/trino/sql/parser/TestStatementSplitter.java b/core/trino-parser/src/test/java/io/trino/sql/parser/TestStatementSplitter.java
index 80f4d52d5f8af..9b0d471065a5f 100644
--- a/core/trino-parser/src/test/java/io/trino/sql/parser/TestStatementSplitter.java
+++ b/core/trino-parser/src/test/java/io/trino/sql/parser/TestStatementSplitter.java
@@ -15,7 +15,7 @@
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
-import org.testng.annotations.Test;
+import org.junit.jupiter.api.Test;
import java.util.List;
@@ -23,9 +23,9 @@
import static io.trino.sql.parser.StatementSplitter.Statement;
import static io.trino.sql.parser.StatementSplitter.isEmptyStatement;
import static io.trino.sql.parser.StatementSplitter.squeezeStatement;
-import static org.testng.Assert.assertEquals;
-import static org.testng.Assert.assertFalse;
-import static org.testng.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
public class TestStatementSplitter
{
@@ -33,48 +33,48 @@ public class TestStatementSplitter
public void testSplitterIncomplete()
{
StatementSplitter splitter = new StatementSplitter(" select * FROM foo ");
- assertEquals(splitter.getCompleteStatements(), ImmutableList.of());
- assertEquals(splitter.getPartialStatement(), "select * FROM foo");
+ assertEquals(ImmutableList.of(), splitter.getCompleteStatements());
+ assertEquals("select * FROM foo", splitter.getPartialStatement());
}
@Test
public void testSplitterEmptyInput()
{
StatementSplitter splitter = new StatementSplitter("");
- assertEquals(splitter.getCompleteStatements(), ImmutableList.of());
- assertEquals(splitter.getPartialStatement(), "");
+ assertEquals(ImmutableList.of(), splitter.getCompleteStatements());
+ assertEquals("", splitter.getPartialStatement());
}
@Test
public void testSplitterEmptyStatements()
{
StatementSplitter splitter = new StatementSplitter(";;;");
- assertEquals(splitter.getCompleteStatements(), ImmutableList.of());
- assertEquals(splitter.getPartialStatement(), "");
+ assertEquals(ImmutableList.of(), splitter.getCompleteStatements());
+ assertEquals("", splitter.getPartialStatement());
}
@Test
public void testSplitterSingle()
{
StatementSplitter splitter = new StatementSplitter("select * from foo;");
- assertEquals(splitter.getCompleteStatements(), statements("select * from foo", ";"));
- assertEquals(splitter.getPartialStatement(), "");
+ assertEquals(statements("select * from foo", ";"), splitter.getCompleteStatements());
+ assertEquals("", splitter.getPartialStatement());
}
@Test
public void testSplitterMultiple()
{
StatementSplitter splitter = new StatementSplitter(" select * from foo ; select * from t; select * from ");
- assertEquals(splitter.getCompleteStatements(), statements("select * from foo", ";", "select * from t", ";"));
- assertEquals(splitter.getPartialStatement(), "select * from");
+ assertEquals(statements("select * from foo", ";", "select * from t", ";"), splitter.getCompleteStatements());
+ assertEquals("select * from", splitter.getPartialStatement());
}
@Test
public void testSplitterMultipleWithEmpty()
{
StatementSplitter splitter = new StatementSplitter("; select * from foo ; select * from t;;;select * from ");
- assertEquals(splitter.getCompleteStatements(), statements("select * from foo", ";", "select * from t", ";"));
- assertEquals(splitter.getPartialStatement(), "select * from");
+ assertEquals(statements("select * from foo", ";", "select * from t", ";"), splitter.getCompleteStatements());
+ assertEquals("select * from", splitter.getPartialStatement());
}
@Test
@@ -82,24 +82,24 @@ public void testSplitterCustomDelimiters()
{
String sql = "// select * from foo // select * from t;//select * from ";
StatementSplitter splitter = new StatementSplitter(sql, ImmutableSet.of(";", "//"));
- assertEquals(splitter.getCompleteStatements(), statements("select * from foo", "//", "select * from t", ";"));
- assertEquals(splitter.getPartialStatement(), "select * from");
+ assertEquals(statements("select * from foo", "//", "select * from t", ";"), splitter.getCompleteStatements());
+ assertEquals("select * from", splitter.getPartialStatement());
}
@Test
public void testSplitterErrorBeforeComplete()
{
StatementSplitter splitter = new StatementSplitter(" select * from z# oops ; select ");
- assertEquals(splitter.getCompleteStatements(), statements("select * from z# oops", ";"));
- assertEquals(splitter.getPartialStatement(), "select");
+ assertEquals(statements("select * from z# oops", ";"), splitter.getCompleteStatements());
+ assertEquals("select", splitter.getPartialStatement());
}
@Test
public void testSplitterErrorAfterComplete()
{
StatementSplitter splitter = new StatementSplitter("select * from foo; select z# oops ");
- assertEquals(splitter.getCompleteStatements(), statements("select * from foo", ";"));
- assertEquals(splitter.getPartialStatement(), "select z# oops");
+ assertEquals(statements("select * from foo", ";"), splitter.getCompleteStatements());
+ assertEquals("select z# oops", splitter.getPartialStatement());
}
@Test
@@ -107,8 +107,8 @@ public void testSplitterWithQuotedString()
{
String sql = "select 'foo bar' x from dual";
StatementSplitter splitter = new StatementSplitter(sql);
- assertEquals(splitter.getCompleteStatements(), ImmutableList.of());
- assertEquals(splitter.getPartialStatement(), sql);
+ assertEquals(ImmutableList.of(), splitter.getCompleteStatements());
+ assertEquals(sql, splitter.getPartialStatement());
}
@Test
@@ -116,8 +116,8 @@ public void testSplitterWithIncompleteQuotedString()
{
String sql = "select 'foo', 'bar";
StatementSplitter splitter = new StatementSplitter(sql);
- assertEquals(splitter.getCompleteStatements(), ImmutableList.of());
- assertEquals(splitter.getPartialStatement(), sql);
+ assertEquals(ImmutableList.of(), splitter.getCompleteStatements());
+ assertEquals(sql, splitter.getPartialStatement());
}
@Test
@@ -125,8 +125,8 @@ public void testSplitterWithEscapedSingleQuote()
{
String sql = "select 'hello''world' from dual";
StatementSplitter splitter = new StatementSplitter(sql + ";");
- assertEquals(splitter.getCompleteStatements(), statements(sql, ";"));
- assertEquals(splitter.getPartialStatement(), "");
+ assertEquals(statements(sql, ";"), splitter.getCompleteStatements());
+ assertEquals("", splitter.getPartialStatement());
}
@Test
@@ -134,8 +134,8 @@ public void testSplitterWithQuotedIdentifier()
{
String sql = "select \"0\"\"bar\" from dual";
StatementSplitter splitter = new StatementSplitter(sql + ";");
- assertEquals(splitter.getCompleteStatements(), statements(sql, ";"));
- assertEquals(splitter.getPartialStatement(), "");
+ assertEquals(statements(sql, ";"), splitter.getCompleteStatements());
+ assertEquals("", splitter.getPartialStatement());
}
@Test
@@ -143,8 +143,8 @@ public void testSplitterWithBackquote()
{
String sql = "select ` f``o o ` from dual";
StatementSplitter splitter = new StatementSplitter(sql);
- assertEquals(splitter.getCompleteStatements(), ImmutableList.of());
- assertEquals(splitter.getPartialStatement(), sql);
+ assertEquals(ImmutableList.of(), splitter.getCompleteStatements());
+ assertEquals(sql, splitter.getPartialStatement());
}
@Test
@@ -152,24 +152,24 @@ public void testSplitterWithDigitIdentifier()
{
String sql = "select 1x from dual";
StatementSplitter splitter = new StatementSplitter(sql);
- assertEquals(splitter.getCompleteStatements(), ImmutableList.of());
- assertEquals(splitter.getPartialStatement(), sql);
+ assertEquals(ImmutableList.of(), splitter.getCompleteStatements());
+ assertEquals(sql, splitter.getPartialStatement());
}
@Test
public void testSplitterWithSingleLineComment()
{
StatementSplitter splitter = new StatementSplitter("--empty\n;-- start\nselect * -- junk\n-- hi\nfrom foo; -- done");
- assertEquals(splitter.getCompleteStatements(), statements("--empty", ";", "-- start\nselect * -- junk\n-- hi\nfrom foo", ";"));
- assertEquals(splitter.getPartialStatement(), "-- done");
+ assertEquals(statements("--empty", ";", "-- start\nselect * -- junk\n-- hi\nfrom foo", ";"), splitter.getCompleteStatements());
+ assertEquals("-- done", splitter.getPartialStatement());
}
@Test
public void testSplitterWithMultiLineComment()
{
StatementSplitter splitter = new StatementSplitter("/* empty */;/* start */ select * /* middle */ from foo; /* end */");
- assertEquals(splitter.getCompleteStatements(), statements("/* empty */", ";", "/* start */ select * /* middle */ from foo", ";"));
- assertEquals(splitter.getPartialStatement(), "/* end */");
+ assertEquals(statements("/* empty */", ";", "/* start */ select * /* middle */ from foo", ";"), splitter.getCompleteStatements());
+ assertEquals("/* end */", splitter.getPartialStatement());
}
@Test
@@ -177,8 +177,8 @@ public void testSplitterWithSingleLineCommentPartial()
{
String sql = "-- start\nselect * -- junk\n-- hi\nfrom foo -- done";
StatementSplitter splitter = new StatementSplitter(sql);
- assertEquals(splitter.getCompleteStatements(), ImmutableList.of());
- assertEquals(splitter.getPartialStatement(), sql);
+ assertEquals(ImmutableList.of(), splitter.getCompleteStatements());
+ assertEquals(sql, splitter.getPartialStatement());
}
@Test
@@ -186,8 +186,8 @@ public void testSplitterWithMultiLineCommentPartial()
{
String sql = "/* start */ select * /* middle */ from foo /* end */";
StatementSplitter splitter = new StatementSplitter(sql);
- assertEquals(splitter.getCompleteStatements(), ImmutableList.of());
- assertEquals(splitter.getPartialStatement(), sql);
+ assertEquals(ImmutableList.of(), splitter.getCompleteStatements());
+ assertEquals(sql, splitter.getPartialStatement());
}
@Test
@@ -208,35 +208,35 @@ public void testIsEmptyStatement()
public void testSqueezeStatement()
{
String sql = "select * from\n foo\n order by x ; ";
- assertEquals(squeezeStatement(sql), "select * from foo order by x ;");
+ assertEquals("select * from foo order by x ;", squeezeStatement(sql));
}
@Test
public void testSqueezeStatementWithIncompleteQuotedString()
{
String sql = "select * from\n foo\n where x = 'oops";
- assertEquals(squeezeStatement(sql), "select * from foo where x = 'oops");
+ assertEquals("select * from foo where x = 'oops", squeezeStatement(sql));
}
@Test
public void testSqueezeStatementWithBackquote()
{
String sql = "select ` f``o o`` ` from dual";
- assertEquals(squeezeStatement(sql), "select ` f``o o`` ` from dual");
+ assertEquals("select ` f``o o`` ` from dual", squeezeStatement(sql));
}
@Test
public void testSqueezeStatementAlternateDelimiter()
{
String sql = "select * from\n foo\n order by x // ";
- assertEquals(squeezeStatement(sql), "select * from foo order by x //");
+ assertEquals("select * from foo order by x //", squeezeStatement(sql));
}
@Test
public void testSqueezeStatementError()
{
String sql = "select * from z#oops";
- assertEquals(squeezeStatement(sql), "select * from z#oops");
+ assertEquals("select * from z#oops", squeezeStatement(sql));
}
private static List statements(String... args)
diff --git a/core/trino-parser/src/test/java/io/trino/sql/parser/TestTypeParser.java b/core/trino-parser/src/test/java/io/trino/sql/parser/TestTypeParser.java
index eca1ada4fd6df..0511a28d654bd 100644
--- a/core/trino-parser/src/test/java/io/trino/sql/parser/TestTypeParser.java
+++ b/core/trino-parser/src/test/java/io/trino/sql/parser/TestTypeParser.java
@@ -13,7 +13,7 @@
*/
package io.trino.sql.parser;
-import org.testng.annotations.Test;
+import org.junit.jupiter.api.Test;
import static io.trino.sql.parser.ParserAssert.type;
import static io.trino.sql.parser.TreeNodes.dateTimeType;
diff --git a/core/trino-parser/src/test/java/io/trino/sql/tree/TestLikePredicate.java b/core/trino-parser/src/test/java/io/trino/sql/tree/TestLikePredicate.java
index e864efa430760..472bc90d972bb 100644
--- a/core/trino-parser/src/test/java/io/trino/sql/tree/TestLikePredicate.java
+++ b/core/trino-parser/src/test/java/io/trino/sql/tree/TestLikePredicate.java
@@ -14,11 +14,11 @@
package io.trino.sql.tree;
import com.google.common.collect.ImmutableList;
-import org.testng.annotations.Test;
+import org.junit.jupiter.api.Test;
import java.util.Optional;
-import static org.testng.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
public class TestLikePredicate
{
@@ -29,7 +29,7 @@ public void testGetChildren()
StringLiteral pattern = new StringLiteral("b");
StringLiteral escape = new StringLiteral("c");
- assertEquals(new LikePredicate(value, pattern, escape).getChildren(), ImmutableList.of(value, pattern, escape));
- assertEquals(new LikePredicate(value, pattern, Optional.empty()).getChildren(), ImmutableList.of(value, pattern));
+ assertEquals(ImmutableList.of(value, pattern, escape), new LikePredicate(value, pattern, escape).getChildren());
+ assertEquals(ImmutableList.of(value, pattern), new LikePredicate(value, pattern, Optional.empty()).getChildren());
}
}
diff --git a/core/trino-parser/src/test/java/io/trino/type/TestTypeCalculation.java b/core/trino-parser/src/test/java/io/trino/type/TestTypeCalculation.java
index d5b6e48f799db..3bd8df1e831b7 100644
--- a/core/trino-parser/src/test/java/io/trino/type/TestTypeCalculation.java
+++ b/core/trino-parser/src/test/java/io/trino/type/TestTypeCalculation.java
@@ -14,37 +14,37 @@
package io.trino.type;
import com.google.common.collect.ImmutableMap;
-import org.testng.annotations.Test;
+import org.junit.jupiter.api.Test;
import static io.trino.type.TypeCalculation.calculateLiteralValue;
-import static org.testng.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
public class TestTypeCalculation
{
@Test
public void testBasicUsage()
{
- assertEquals(calculateLiteralValue("42", ImmutableMap.of()), Long.valueOf(42));
- assertEquals(calculateLiteralValue("NULL", ImmutableMap.of()), Long.valueOf(0));
- assertEquals(calculateLiteralValue("null", ImmutableMap.of()), Long.valueOf(0));
- assertEquals(calculateLiteralValue("x", ImmutableMap.of("x", 42L)), Long.valueOf(42));
- assertEquals(calculateLiteralValue("(42)", ImmutableMap.of()), Long.valueOf(42));
- assertEquals(calculateLiteralValue("(NULL)", ImmutableMap.of()), Long.valueOf(0));
- assertEquals(calculateLiteralValue("(x)", ImmutableMap.of("x", 42L)), Long.valueOf(42));
+ assertEquals(Long.valueOf(42), calculateLiteralValue("42", ImmutableMap.of()));
+ assertEquals(Long.valueOf(0), calculateLiteralValue("NULL", ImmutableMap.of()));
+ assertEquals(Long.valueOf(0), calculateLiteralValue("null", ImmutableMap.of()));
+ assertEquals(Long.valueOf(42), calculateLiteralValue("x", ImmutableMap.of("x", 42L)));
+ assertEquals(Long.valueOf(42), calculateLiteralValue("(42)", ImmutableMap.of()));
+ assertEquals(Long.valueOf(0), calculateLiteralValue("(NULL)", ImmutableMap.of()));
+ assertEquals(Long.valueOf(42), calculateLiteralValue("(x)", ImmutableMap.of("x", 42L)));
- assertEquals(calculateLiteralValue("42 + 55", ImmutableMap.of()), Long.valueOf(42 + 55));
- assertEquals(calculateLiteralValue("42 - 55", ImmutableMap.of()), Long.valueOf(42 - 55));
- assertEquals(calculateLiteralValue("42 * 55", ImmutableMap.of()), Long.valueOf(42 * 55));
- assertEquals(calculateLiteralValue("42 / 6", ImmutableMap.of()), Long.valueOf(42 / 6));
+ assertEquals(Long.valueOf(42 + 55), calculateLiteralValue("42 + 55", ImmutableMap.of()));
+ assertEquals(Long.valueOf(42 - 55), calculateLiteralValue("42 - 55", ImmutableMap.of()));
+ assertEquals(Long.valueOf(42 * 55), calculateLiteralValue("42 * 55", ImmutableMap.of()));
+ assertEquals(Long.valueOf(42 / 6), calculateLiteralValue("42 / 6", ImmutableMap.of()));
- assertEquals(calculateLiteralValue("42 + 55 * 6", ImmutableMap.of()), Long.valueOf(42 + 55 * 6));
- assertEquals(calculateLiteralValue("(42 + 55) * 6", ImmutableMap.of()), Long.valueOf((42 + 55) * 6));
+ assertEquals(Long.valueOf(42 + 55 * 6), calculateLiteralValue("42 + 55 * 6", ImmutableMap.of()));
+ assertEquals(Long.valueOf((42 + 55) * 6), calculateLiteralValue("(42 + 55) * 6", ImmutableMap.of()));
- assertEquals(calculateLiteralValue("min(10,2)", ImmutableMap.of()), Long.valueOf(2));
- assertEquals(calculateLiteralValue("min(10,2*10)", ImmutableMap.of()), Long.valueOf(10));
- assertEquals(calculateLiteralValue("max(10,2*10)", ImmutableMap.of()), Long.valueOf(20));
- assertEquals(calculateLiteralValue("max(10,2)", ImmutableMap.of()), Long.valueOf(10));
+ assertEquals(Long.valueOf(2), calculateLiteralValue("min(10,2)", ImmutableMap.of()));
+ assertEquals(Long.valueOf(10), calculateLiteralValue("min(10,2*10)", ImmutableMap.of()));
+ assertEquals(Long.valueOf(20), calculateLiteralValue("max(10,2*10)", ImmutableMap.of()));
+ assertEquals(Long.valueOf(10), calculateLiteralValue("max(10,2)", ImmutableMap.of()));
- assertEquals(calculateLiteralValue("x + y", ImmutableMap.of("x", 42L, "y", 55L)), Long.valueOf(42 + 55));
+ assertEquals(Long.valueOf(42 + 55), calculateLiteralValue("x + y", ImmutableMap.of("x", 42L, "y", 55L)));
}
}