Skip to content

Commit

Permalink
Update parser unit tests to JUnit
Browse files Browse the repository at this point in the history
  • Loading branch information
@martint
martint committed Dec 24, 2021
1 parent 0a4e629 commit fa617f0
Show file tree
Hide file tree
Showing 9 changed files with 271 additions and 231 deletions.
20 changes: 16 additions & 4 deletions core/trino-parser/pom.xml
View file
Original file line number Diff line number Diff line change
Expand Up @@ -41,14 +41,26 @@

<!-- for testing -->
<dependency>
<groupId>io.trino</groupId>
<artifactId>trino-testing-services</artifactId>
<groupId>org.assertj</groupId>
<artifactId>assertj-core</artifactId>
<scope>test</scope>
</dependency>

<dependency>
<groupId>org.assertj</groupId>
<artifactId>assertj-core</artifactId>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<scope>test</scope>
</dependency>

<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<scope>test</scope>
</dependency>

<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-params</artifactId>
<scope>test</scope>
</dependency>

Expand Down
2 changes: 1 addition & 1 deletion core/trino-parser/src/test/java/io/trino/sql/parser/TestParsingException.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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;

Expand Down
26 changes: 16 additions & 10 deletions core/trino-parser/src/test/java/io/trino/sql/parser/TestSqlParser.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand Down Expand Up @@ -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
{
Expand All @@ -282,7 +283,8 @@ public void testPossibleExponentialBacktracking()
createExpression("(((((((((((((((((((((((((((true)))))))))))))))))))))))))))");
}

@Test(timeOut = 2_000)
@Test
@Timeout(value = 2, unit = SECONDS)
public void testPotentialUnboundedLookahead()
{
createExpression("(\n" +
Expand All @@ -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
Expand Down Expand Up @@ -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
Expand Down
302 changes: 162 additions & 140 deletions core/trino-parser/src/test/java/io/trino/sql/parser/TestSqlParserErrorHandling.java
View file

Large diffs are not rendered by default.

8 changes: 4 additions & 4 deletions core/trino-parser/src/test/java/io/trino/sql/parser/TestStatementBuilder.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand All @@ -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
{
Expand Down Expand Up @@ -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)
Expand Down
94 changes: 47 additions & 47 deletions core/trino-parser/src/test/java/io/trino/sql/parser/TestStatementSplitter.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -15,179 +15,179 @@

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;

import static com.google.common.base.Preconditions.checkArgument;
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
{
@Test
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
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
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
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
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
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
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
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
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
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
Expand All @@ -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<Statement> statements(String... args)
Expand Down

0 comments on commit fa617f0

Please sign in to comment.