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