This is an automated email from the ASF dual-hosted git repository.
jhyde pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/calcite.git
The following commit(s) were added to refs/heads/main by this push:
new e92a5fcaba [CALCITE-5611] In SqlOperatorTest, show SQL for failed tests
e92a5fcaba is described below
commit e92a5fcaba2db7416f09331614985b6ca2d7e6a3
Author: Sergey Nuyanzin <[email protected]>
AuthorDate: Sun Mar 26 20:48:44 2023 +0200
[CALCITE-5611] In SqlOperatorTest, show SQL for failed tests
Close apache/calcite#3131
---
.../apache/calcite/sql/test/AbstractSqlTester.java | 2 +-
.../apache/calcite/sql/test/ResultCheckers.java | 52 ++++++++++++----------
.../org/apache/calcite/sql/test/SqlTester.java | 5 ++-
.../java/org/apache/calcite/sql/test/SqlTests.java | 13 +++---
.../calcite/test/SqlOperatorFixtureImpl.java | 2 +-
.../org/apache/calcite/test/SqlOperatorTest.java | 8 ++--
.../java/org/apache/calcite/test/FixtureTest.java | 12 ++---
7 files changed, 50 insertions(+), 44 deletions(-)
diff --git
a/testkit/src/main/java/org/apache/calcite/sql/test/AbstractSqlTester.java
b/testkit/src/main/java/org/apache/calcite/sql/test/AbstractSqlTester.java
index d68b381cba..8f5defe162 100644
--- a/testkit/src/main/java/org/apache/calcite/sql/test/AbstractSqlTester.java
+++ b/testkit/src/main/java/org/apache/calcite/sql/test/AbstractSqlTester.java
@@ -234,7 +234,7 @@ public abstract class AbstractSqlTester implements
SqlTester, AutoCloseable {
RelDataType actualType = getColumnType(factory, query);
// Check result type.
- typeChecker.checkType(actualType);
+ typeChecker.checkType(() -> "Query: " + query, actualType);
Pair<SqlValidator, SqlNode> p = parseAndValidate(factory, query);
SqlValidator validator = requireNonNull(p.left);
diff --git
a/testkit/src/main/java/org/apache/calcite/sql/test/ResultCheckers.java
b/testkit/src/main/java/org/apache/calcite/sql/test/ResultCheckers.java
index 69fad877f1..3ecf527b9e 100644
--- a/testkit/src/main/java/org/apache/calcite/sql/test/ResultCheckers.java
+++ b/testkit/src/main/java/org/apache/calcite/sql/test/ResultCheckers.java
@@ -114,15 +114,17 @@ public class ResultCheckers {
* Compares the first column of a result set against a String-valued
* reference set, disregarding order entirely.
*
+ * @param sql SQL to show in case of failure
* @param resultSet Result set
* @param refSet Expected results
* @throws Exception .
*/
- static void compareResultSet(ResultSet resultSet,
+ static void compareResultSet(String sql, ResultSet resultSet,
Set<String> refSet) throws Exception {
Set<String> actualSet = new HashSet<>();
final int columnType = resultSet.getMetaData().getColumnType(1);
final ColumnMetaData.Rep rep = rep(columnType);
+ final String msg = "Query: " + sql;
while (resultSet.next()) {
final String s = resultSet.getString(1);
final String s0 = s == null ? "0" : s;
@@ -131,7 +133,7 @@ public class ResultCheckers {
switch (rep) {
case BOOLEAN:
case PRIMITIVE_BOOLEAN:
- assertThat(resultSet.getBoolean(1), equalTo(Boolean.valueOf(s)));
+ assertThat(msg, resultSet.getBoolean(1), equalTo(Boolean.valueOf(s)));
break;
case BYTE:
case PRIMITIVE_BYTE:
@@ -148,18 +150,18 @@ public class ResultCheckers {
// Large integers come out in scientific format, say "5E+06"
l = (long) Double.parseDouble(s0);
}
- assertThat(resultSet.getByte(1), equalTo((byte) l));
- assertThat(resultSet.getShort(1), equalTo((short) l));
- assertThat(resultSet.getInt(1), equalTo((int) l));
- assertThat(resultSet.getLong(1), equalTo(l));
+ assertThat(msg, resultSet.getByte(1), equalTo((byte) l));
+ assertThat(msg, resultSet.getShort(1), equalTo((short) l));
+ assertThat(msg, resultSet.getInt(1), equalTo((int) l));
+ assertThat(msg, resultSet.getLong(1), equalTo(l));
break;
case FLOAT:
case PRIMITIVE_FLOAT:
case DOUBLE:
case PRIMITIVE_DOUBLE:
final double d = Double.parseDouble(s0);
- assertThat(resultSet.getFloat(1), equalTo((float) d));
- assertThat(resultSet.getDouble(1), equalTo(d));
+ assertThat(msg, resultSet.getFloat(1), equalTo((float) d));
+ assertThat(msg, resultSet.getDouble(1), equalTo(d));
break;
default:
// fall through; no type-specific validation is necessary
@@ -167,12 +169,12 @@ public class ResultCheckers {
final boolean wasNull1 = resultSet.wasNull();
final Object object = resultSet.getObject(1);
final boolean wasNull2 = resultSet.wasNull();
- assertThat(object == null, equalTo(wasNull0));
- assertThat(wasNull1, equalTo(wasNull0));
- assertThat(wasNull2, equalTo(wasNull0));
+ assertThat(msg, object == null, equalTo(wasNull0));
+ assertThat(msg, wasNull1, equalTo(wasNull0));
+ assertThat(msg, wasNull2, equalTo(wasNull0));
}
resultSet.close();
- assertEquals(refSet, actualSet);
+ assertEquals(refSet, actualSet, msg);
}
private static ColumnMetaData.Rep rep(int columnType) {
@@ -206,20 +208,21 @@ public class ResultCheckers {
* Compares the first column of a result set against a pattern. The result
* set must return exactly one row.
*
+ * @param sql SQL to show in case of failure
* @param resultSet Result set
* @param pattern Expected pattern
*/
- static void compareResultSetWithPattern(ResultSet resultSet,
+ static void compareResultSetWithPattern(String sql, ResultSet resultSet,
Pattern pattern) throws Exception {
if (!resultSet.next()) {
- fail("Query returned 0 rows, expected 1");
+ fail("Query \"" + sql + "\"returned 0 rows, expected 1");
}
String actual = resultSet.getString(1);
if (resultSet.next()) {
- fail("Query returned 2 or more rows, expected 1");
+ fail("Query \"" + sql + "\"returned 2 or more rows, expected 1");
}
if (!pattern.matcher(actual).matches()) {
- fail("Query returned '"
+ fail("Query \"" + sql + "\"returned '"
+ actual
+ "', expected '"
+ pattern.pattern()
@@ -231,12 +234,13 @@ public class ResultCheckers {
* Compares the first column of a result set against a {@link Matcher}.
* The result set must return exactly one row.
*
+ * @param sql SQL to show in case of failure
* @param resultSet Result set
* @param matcher Matcher
*
* @param <T> Value type
*/
- static <T> void compareResultSetWithMatcher(ResultSet resultSet,
+ static <T> void compareResultSetWithMatcher(String sql, ResultSet resultSet,
JdbcType<T> jdbcType, Matcher<T> matcher) throws Exception {
if (!resultSet.next()) {
fail("Query returned 0 rows, expected 1");
@@ -245,7 +249,7 @@ public class ResultCheckers {
if (resultSet.next()) {
fail("Query returned 2 or more rows, expected 1");
}
- assertThat(actual, matcher);
+ assertThat("Query: " + sql, actual, matcher);
}
/** Creates a ResultChecker that accesses a column of a given type
@@ -294,8 +298,8 @@ public class ResultCheckers {
this.pattern = requireNonNull(pattern, "pattern");
}
- @Override public void checkResult(ResultSet resultSet) throws Exception {
- compareResultSetWithPattern(resultSet, pattern);
+ @Override public void checkResult(String sql, ResultSet resultSet) throws
Exception {
+ compareResultSetWithPattern(sql, resultSet, pattern);
}
}
@@ -313,8 +317,8 @@ public class ResultCheckers {
this.jdbcType = requireNonNull(jdbcType, "jdbcType");
}
- @Override public void checkResult(ResultSet resultSet) throws Exception {
- compareResultSetWithMatcher(resultSet, jdbcType, matcher);
+ @Override public void checkResult(String sql, ResultSet resultSet) throws
Exception {
+ compareResultSetWithMatcher(sql, resultSet, jdbcType, matcher);
}
}
@@ -328,8 +332,8 @@ public class ResultCheckers {
this.expected = ImmutableNullableSet.copyOf(expected);
}
- @Override public void checkResult(ResultSet resultSet) throws Exception {
- compareResultSet(resultSet, expected);
+ @Override public void checkResult(String sql, ResultSet resultSet) throws
Exception {
+ compareResultSet(sql, resultSet, expected);
}
}
}
diff --git a/testkit/src/main/java/org/apache/calcite/sql/test/SqlTester.java
b/testkit/src/main/java/org/apache/calcite/sql/test/SqlTester.java
index c8c76556b6..19365ce94f 100644
--- a/testkit/src/main/java/org/apache/calcite/sql/test/SqlTester.java
+++ b/testkit/src/main/java/org/apache/calcite/sql/test/SqlTester.java
@@ -31,6 +31,7 @@ import org.checkerframework.checker.nullness.qual.Nullable;
import java.sql.ResultSet;
import java.util.function.Consumer;
+import java.util.function.Supplier;
import static java.util.Objects.requireNonNull;
@@ -320,7 +321,7 @@ public interface SqlTester extends AutoCloseable {
/** Type checker. */
interface TypeChecker {
- void checkType(RelDataType type);
+ void checkType(Supplier<String> sql, RelDataType type);
}
/** Parameter checker. */
@@ -330,7 +331,7 @@ public interface SqlTester extends AutoCloseable {
/** Result checker. */
interface ResultChecker {
- void checkResult(ResultSet result) throws Exception;
+ void checkResult(String sql, ResultSet result) throws Exception;
}
/** Action that is called after validation.
diff --git a/testkit/src/main/java/org/apache/calcite/sql/test/SqlTests.java
b/testkit/src/main/java/org/apache/calcite/sql/test/SqlTests.java
index 01d7277833..d3712ebaeb 100644
--- a/testkit/src/main/java/org/apache/calcite/sql/test/SqlTests.java
+++ b/testkit/src/main/java/org/apache/calcite/sql/test/SqlTests.java
@@ -33,6 +33,7 @@ import org.checkerframework.checker.nullness.qual.Nullable;
import java.util.Arrays;
import java.util.List;
+import java.util.function.Supplier;
import java.util.regex.Pattern;
import static org.apache.calcite.sql.test.SqlTester.ParameterChecker;
@@ -58,7 +59,7 @@ public abstract class SqlTests {
/**
* Checker which allows any type.
*/
- public static final TypeChecker ANY_TYPE_CHECKER = type -> {
+ public static final TypeChecker ANY_TYPE_CHECKER = (sql, type) -> {
};
/**
@@ -70,7 +71,7 @@ public abstract class SqlTests {
/**
* Checker that allows any result.
*/
- public static final ResultChecker ANY_RESULT_CHECKER = result -> {
+ public static final ResultChecker ANY_RESULT_CHECKER = (sql, result) -> {
while (true) {
if (!result.next()) {
break;
@@ -424,8 +425,8 @@ public abstract class SqlTests {
this.typeName = typeName;
}
- @Override public void checkType(RelDataType type) {
- assertThat(type.toString(), is(typeName.toString()));
+ @Override public void checkType(Supplier<String> sql, RelDataType type) {
+ assertThat(sql.get(), type.toString(), is(typeName.toString()));
}
}
@@ -450,9 +451,9 @@ public abstract class SqlTests {
this.expected = expected;
}
- @Override public void checkType(RelDataType type) {
+ @Override public void checkType(Supplier<String> sql, RelDataType type) {
String actual = getTypeString(type);
- assertThat(actual, is(expected));
+ assertThat(sql.get(), actual, is(expected));
}
}
diff --git
a/testkit/src/main/java/org/apache/calcite/test/SqlOperatorFixtureImpl.java
b/testkit/src/main/java/org/apache/calcite/test/SqlOperatorFixtureImpl.java
index a3232e8bdf..fcf848d8a4 100644
--- a/testkit/src/main/java/org/apache/calcite/test/SqlOperatorFixtureImpl.java
+++ b/testkit/src/main/java/org/apache/calcite/test/SqlOperatorFixtureImpl.java
@@ -140,7 +140,7 @@ class SqlOperatorFixtureImpl implements SqlOperatorFixture {
assertEquals(1, fields.size(), "expected query to return 1 field");
final RelDataType actualType = fields.get(0).getType();
String actual = SqlTests.getTypeString(actualType);
- assertThat(actual, matcher);
+ assertThat("Query: " + sql.sql, actual, matcher);
};
}
diff --git a/testkit/src/main/java/org/apache/calcite/test/SqlOperatorTest.java
b/testkit/src/main/java/org/apache/calcite/test/SqlOperatorTest.java
index ae4ff74037..42e946a4ef 100644
--- a/testkit/src/main/java/org/apache/calcite/test/SqlOperatorTest.java
+++ b/testkit/src/main/java/org/apache/calcite/test/SqlOperatorTest.java
@@ -10600,7 +10600,7 @@ public class SqlOperatorTest {
query = AbstractSqlTester.buildQuery(s);
}
f.check(query, SqlTests.ANY_TYPE_CHECKER,
- SqlTests.ANY_PARAMETER_CHECKER, result -> { });
+ SqlTests.ANY_PARAMETER_CHECKER, (sql, result) -> { });
}
} catch (Throwable e) {
// Logging the top-level throwable directly makes the message
@@ -10662,7 +10662,7 @@ public class SqlOperatorTest {
this.patterns = patterns;
}
- @Override public void checkResult(ResultSet result) throws Exception {
+ @Override public void checkResult(String sql, ResultSet result) throws
Exception {
Throwable thrown = null;
try {
if (!result.next()) {
@@ -10670,7 +10670,7 @@ public class SqlOperatorTest {
return;
}
final Object actual = result.getObject(1);
- assertEquals(expected, actual);
+ assertEquals(expected, actual, () -> "Query: " + sql);
} catch (SQLException e) {
thrown = e;
}
@@ -10723,7 +10723,7 @@ public class SqlOperatorTest {
Statement statement = connection.createStatement()) {
final ResultSet resultSet =
statement.executeQuery(query);
- resultChecker.checkResult(resultSet);
+ resultChecker.checkResult(query, resultSet);
} catch (Exception e) {
throw TestUtil.rethrow(e);
}
diff --git a/testkit/src/test/java/org/apache/calcite/test/FixtureTest.java
b/testkit/src/test/java/org/apache/calcite/test/FixtureTest.java
index eeb6997ff4..9e963b1c6c 100644
--- a/testkit/src/test/java/org/apache/calcite/test/FixtureTest.java
+++ b/testkit/src/test/java/org/apache/calcite/test/FixtureTest.java
@@ -95,12 +95,12 @@ public class FixtureTest {
// The fixture that executes fails, because the result value is incorrect.
validateFixture.checkBoolean("1 < 5", false);
assertFails(() -> executeFixture.checkBoolean("1 < 5", false),
- "<false>", "<true>");
+ "Query: values (1 < 5)", "<false>", "<true>");
// The fixture that executes fails, because the result value is incorrect.
validateFixture.checkScalarExact("1 + 2", "INTEGER NOT NULL", "foo");
assertFails(() -> validateFixture.checkScalarExact("1 + 2", "DATE", "foo"),
- "\"DATE\"", "\"INTEGER NOT NULL\"");
+ "Query: values (1 + 2)", "\"DATE\"", "\"INTEGER NOT NULL\"");
// Both fixtures pass.
validateFixture.checkScalarExact("1 + 2", "INTEGER NOT NULL", "3");
@@ -108,17 +108,17 @@ public class FixtureTest {
// Both fixtures fail, because the type is incorrect.
assertFails(() -> validateFixture.checkScalarExact("1 + 2", "DATE", "foo"),
- "\"DATE\"", "\"INTEGER NOT NULL\"");
+ "Query: values (1 + 2)", "\"DATE\"", "\"INTEGER NOT NULL\"");
assertFails(() -> executeFixture.checkScalarExact("1 + 2", "DATE", "foo"),
- "\"DATE\"", "\"INTEGER NOT NULL\"");
+ "Query: values (1 + 2)", "\"DATE\"", "\"INTEGER NOT NULL\"");
}
- static void assertFails(Runnable runnable, String expected, String actual) {
+ static void assertFails(Runnable runnable, String msg, String expected,
String actual) {
try {
runnable.run();
fail("expected error");
} catch (AssertionError e) {
- String expectedMessage = "\n"
+ String expectedMessage = msg + "\n"
+ "Expected: is " + expected + "\n"
+ " but: was " + actual;
assertThat(e.getMessage(), is(expectedMessage));
