You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@calcite.apache.org by jh...@apache.org on 2024/09/28 23:39:59 UTC
(calcite) branch main updated (a8802c721a -> a4a27e3a48)
This is an automated email from the ASF dual-hosted git repository.
jhyde pushed a change to branch main
in repository https://gitbox.apache.org/repos/asf/calcite.git
from a8802c721a [CALCITE-6593] NPE when outer joining tables with many fields and unmatching rows
new 9985b6af15 Refactor: Migrate from assertEquals to assertThat
new a4a27e3a48 [CALCITE-6560] Allow types with negative scale
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../calcite/adapter/arrow/ArrowAdapterTest.java | 9 +-
build.gradle.kts | 2 +
core/src/main/codegen/templates/Parser.jj | 6 +-
.../org/apache/calcite/jdbc/CalciteMetaImpl.java | 2 +-
.../calcite/rel/type/DelegatingTypeSystem.java | 12 +
.../apache/calcite/rel/type/RelDataTypeSystem.java | 49 +-
.../calcite/rel/type/RelDataTypeSystemImpl.java | 101 ++
.../java/org/apache/calcite/rex/RexBuilder.java | 5 +-
.../apache/calcite/runtime/CalciteResource.java | 6 +
.../apache/calcite/sql/SqlBasicTypeNameSpec.java | 15 +-
.../apache/calcite/sql/SqlIntervalQualifier.java | 2 +-
.../calcite/sql/type/SqlTypeFactoryImpl.java | 17 +-
.../org/apache/calcite/sql/type/SqlTypeName.java | 19 +-
.../org/apache/calcite/sql/type/SqlTypeUtil.java | 8 +-
.../calcite/sql/validate/SqlValidatorImpl.java | 4 +-
.../calcite/runtime/CalciteResource.properties | 4 +
.../calcite/adapter/clone/ArrayTableTest.java | 188 +--
.../adapter/enumerable/EnumerableWindowTest.java | 7 +-
.../calcite/adapter/enumerable/PhysTypeTest.java | 9 +-
.../calcite/interpreter/BindableWindowTest.java | 7 +-
.../calcite/jdbc/CalciteRemoteDriverTest.java | 8 +-
.../apache/calcite/jdbc/JavaTypeFactoryTest.java | 13 +-
.../calcite/materialize/LatticeSuggesterTest.java | 7 +-
.../org/apache/calcite/plan/RelOptUtilTest.java | 50 +-
.../java/org/apache/calcite/plan/RelTraitTest.java | 20 +-
.../plan/volcano/CollationConversionTest.java | 8 +-
.../apache/calcite/plan/volcano/ComboRuleTest.java | 5 +-
.../plan/volcano/MultipleTraitConversionTest.java | 8 +-
.../calcite/plan/volcano/TraitConversionTest.java | 8 +-
.../calcite/plan/volcano/VolcanoPlannerTest.java | 37 +-
.../plan/volcano/VolcanoPlannerTraitTest.java | 41 +-
.../prepare/LookupOperatorOverloadsTest.java | 4 +-
.../calcite/rel/logical/LogicalWindowTest.java | 7 +-
.../apache/calcite/rel/metadata/RelMdUtilTest.java | 21 +-
.../RelMetadataHandlerGeneratorUtilTest.java | 5 +-
.../org/apache/calcite/rex/RexBuilderTest.java | 104 +-
.../org/apache/calcite/rex/RexExecutorTest.java | 5 +-
.../org/apache/calcite/rex/RexProgramTest.java | 25 +-
.../org/apache/calcite/rex/RexProgramTestBase.java | 7 +-
.../apache/calcite/runtime/BinarySearchTest.java | 11 +-
.../calcite/runtime/SpatialTypeUtilsTest.java | 17 +-
.../apache/calcite/sql/test/SqlAdvisorTest.java | 21 +-
.../apache/calcite/sql/test/SqlTypeNameTest.java | 76 +-
.../calcite/sql/type/RelDataTypeSystemTest.java | 78 +-
.../apache/calcite/sql/type/SqlTypeUtilTest.java | 6 +-
.../calcite/sql2rel/RelFieldTrimmerTest.java | 19 +-
.../org/apache/calcite/test/CoreQuidemTest.java | 26 +-
.../calcite/test/CustomRelDataTypeSystem.java | 40 -
.../org/apache/calcite/test/FilteratorTest.java | 20 +-
.../org/apache/calcite/test/HepPlannerTest.java | 18 +-
.../calcite/test/InduceGroupingTypeTest.java | 73 +-
.../apache/calcite/test/JdbcFrontJdbcBackTest.java | 22 +-
.../apache/calcite/test/JdbcFrontLinqBackTest.java | 10 +-
.../java/org/apache/calcite/test/JdbcTest.java | 376 +++--
.../calcite/test/LargeGeneratedJoinTest.java | 83 +-
.../java/org/apache/calcite/test/LatticeTest.java | 14 +-
.../MaterializedViewSubstitutionVisitorTest.java | 3 +-
.../java/org/apache/calcite/test/ModelTest.java | 72 +-
.../org/apache/calcite/test/MutableRelTest.java | 6 +-
.../apache/calcite/test/ReflectiveSchemaTest.java | 25 +-
.../org/apache/calcite/test/RelBuilderTest.java | 9 +-
.../org/apache/calcite/test/RelMetadataTest.java | 27 +-
.../org/apache/calcite/test/RelOptRulesTest.java | 13 +-
.../apache/calcite/test/ScannableTableTest.java | 3 +-
.../org/apache/calcite/test/SqlFunctionsTest.java | 244 +--
.../apache/calcite/test/SqlJsonFunctionsTest.java | 4 +-
.../org/apache/calcite/test/SqlValidatorTest.java | 31 +-
.../calcite/test/fuzzer/RexProgramFuzzyTest.java | 53 +-
.../org/apache/calcite/tools/FrameworksTest.java | 3 +-
.../java/org/apache/calcite/tools/PlannerTest.java | 8 +-
.../java/org/apache/calcite/util/BitSetsTest.java | 40 +-
.../org/apache/calcite/util/ChunkListTest.java | 56 +-
.../org/apache/calcite/util/FormatModelTest.java | 15 +-
.../apache/calcite/util/ImmutableBitSetTest.java | 32 +-
.../java/org/apache/calcite/util/PairListTest.java | 12 +-
.../calcite/util/PartiallyOrderedSetTest.java | 75 +-
.../apache/calcite/util/PermutationTestCase.java | 82 +-
.../apache/calcite/util/ReflectVisitorTest.java | 33 +-
.../java/org/apache/calcite/util/SourceTest.java | 29 +-
.../java/org/apache/calcite/util/UtilTest.java | 470 +++---
.../PostgresqlDateTimeFormatterTest.java | 1733 ++++++++++----------
.../apache/calcite/util/mapping/MappingTest.java | 59 +-
core/src/test/resources/sql/cast.iq | 381 +++++
.../elasticsearch/ElasticsearchJsonTest.java | 33 +-
.../elasticsearch/ElasticsearchVersionTest.java | 21 +-
.../adapter/elasticsearch/Projection2Test.java | 5 +-
.../adapter/elasticsearch/QueryBuildersTest.java | 267 +--
.../apache/calcite/test/ElasticsearchChecker.java | 12 +-
.../test/java/org/apache/calcite/test/CsvTest.java | 31 +-
.../calcite/adapter/file/CsvEnumeratorTest.java | 46 +-
.../calcite/adapter/file/FileAdapterTest.java | 43 +-
.../calcite/adapter/file/FileAdapterTests.java | 9 +-
.../calcite/adapter/file/FileReaderTest.java | 21 +-
.../calcite/adapter/geode/rel/GeodeAssertions.java | 5 +-
.../org/apache/calcite/linq4j/tree/Primitive.java | 5 +
.../calcite/linq4j/function/FunctionTest.java | 24 +-
.../calcite/linq4j/test/BlockBuilderTest.java | 41 +-
.../apache/calcite/linq4j/test/ExpressionTest.java | 722 ++++----
.../apache/calcite/linq4j/test/InlinerTest.java | 37 +-
.../apache/calcite/linq4j/test/LimitSortTest.java | 7 +-
.../org/apache/calcite/linq4j/test/Linq4jTest.java | 523 +++---
.../apache/calcite/linq4j/test/LookupImplTest.java | 7 +-
.../apache/calcite/linq4j/test/OptimizerTest.java | 452 ++---
.../apache/calcite/linq4j/test/PrimitiveTest.java | 62 +-
.../org/apache/calcite/linq4j/tree/TypeTest.java | 17 +-
.../calcite/adapter/mongodb/MongoAdapterTest.java | 7 +-
.../org/apache/calcite/test/PigAdapterTest.java | 5 +-
.../calcite/test/PigRelBuilderStyleTest.java | 5 +-
.../apache/calcite/adapter/os/OsAdapterTest.java | 3 +-
.../java/org/apache/calcite/test/ServerTest.java | 7 +-
.../apache/calcite/sql/parser/SqlParserTest.java | 58 +-
.../apache/calcite/sql/test/AbstractSqlTester.java | 3 +-
.../apache/calcite/sql/test/ResultCheckers.java | 8 +-
.../org/apache/calcite/test/CalciteAssert.java | 10 +-
.../org/apache/calcite/test/CustomTypeSystems.java | 96 ++
.../org/apache/calcite/test/DiffRepository.java | 6 +-
.../java/org/apache/calcite/test/DiffTestCase.java | 6 +-
.../java/org/apache/calcite/test/Matchers.java | 31 +-
.../apache/calcite/test/RelMetadataFixture.java | 13 +-
.../calcite/test/SqlOperatorFixtureImpl.java | 4 +-
.../org/apache/calcite/test/SqlOperatorTest.java | 44 +-
.../java/org/apache/calcite/util/TestUtilTest.java | 6 +-
122 files changed, 4450 insertions(+), 3535 deletions(-)
delete mode 100644 core/src/test/java/org/apache/calcite/test/CustomRelDataTypeSystem.java
create mode 100644 testkit/src/main/java/org/apache/calcite/test/CustomTypeSystems.java
(calcite) 01/02: Refactor: Migrate from assertEquals to assertThat
Posted by jh...@apache.org.
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
commit 9985b6af156d41fc4a986a9aadbf7f8227981388
Author: Julian Hyde <jh...@apache.org>
AuthorDate: Sat Sep 28 15:27:10 2024 -0700
Refactor: Migrate from assertEquals to assertThat
We prefer the Hamcrest style (assertThat and Matcher) to the
Junit Jupiter (Assertions.assertEquals and assertTrue).
Convert
* assertEquals(y, x) to assertThat(x, is(y))
* assertThat(x.toString(), is(y)) to assertThat(x, hasString(y))
* assertThat(x.length, is(y)) to assertThat(x, arrayWithSize(y))
* assertTrue(x.equals(y)) to assertThat(x, is(y))
* assertTrue(x instanceof Y) to assertThat(x, instanceOf(Y.class))
* assertThat(x, is(Arrays.asList(ys))) to assertThat(x, isListOf(ys))
* assertTrue(x == null) to assertThat(x, nullValue())
---
.../calcite/adapter/arrow/ArrowAdapterTest.java | 9 +-
build.gradle.kts | 2 +
.../calcite/adapter/clone/ArrayTableTest.java | 188 +--
.../adapter/enumerable/EnumerableWindowTest.java | 7 +-
.../calcite/adapter/enumerable/PhysTypeTest.java | 9 +-
.../calcite/interpreter/BindableWindowTest.java | 7 +-
.../calcite/jdbc/CalciteRemoteDriverTest.java | 8 +-
.../apache/calcite/jdbc/JavaTypeFactoryTest.java | 13 +-
.../calcite/materialize/LatticeSuggesterTest.java | 7 +-
.../org/apache/calcite/plan/RelOptUtilTest.java | 50 +-
.../java/org/apache/calcite/plan/RelTraitTest.java | 20 +-
.../plan/volcano/CollationConversionTest.java | 8 +-
.../apache/calcite/plan/volcano/ComboRuleTest.java | 5 +-
.../plan/volcano/MultipleTraitConversionTest.java | 8 +-
.../calcite/plan/volcano/TraitConversionTest.java | 8 +-
.../calcite/plan/volcano/VolcanoPlannerTest.java | 37 +-
.../plan/volcano/VolcanoPlannerTraitTest.java | 41 +-
.../prepare/LookupOperatorOverloadsTest.java | 4 +-
.../calcite/rel/logical/LogicalWindowTest.java | 7 +-
.../apache/calcite/rel/metadata/RelMdUtilTest.java | 21 +-
.../RelMetadataHandlerGeneratorUtilTest.java | 5 +-
.../org/apache/calcite/rex/RexBuilderTest.java | 43 +-
.../org/apache/calcite/rex/RexExecutorTest.java | 5 +-
.../org/apache/calcite/rex/RexProgramTest.java | 25 +-
.../org/apache/calcite/rex/RexProgramTestBase.java | 7 +-
.../apache/calcite/runtime/BinarySearchTest.java | 11 +-
.../calcite/runtime/SpatialTypeUtilsTest.java | 17 +-
.../apache/calcite/sql/test/SqlAdvisorTest.java | 21 +-
.../apache/calcite/sql/test/SqlTypeNameTest.java | 76 +-
.../calcite/sql/type/RelDataTypeSystemTest.java | 54 +-
.../apache/calcite/sql/type/SqlTypeUtilTest.java | 6 +-
.../calcite/sql2rel/RelFieldTrimmerTest.java | 19 +-
.../org/apache/calcite/test/FilteratorTest.java | 20 +-
.../org/apache/calcite/test/HepPlannerTest.java | 18 +-
.../calcite/test/InduceGroupingTypeTest.java | 73 +-
.../apache/calcite/test/JdbcFrontJdbcBackTest.java | 22 +-
.../apache/calcite/test/JdbcFrontLinqBackTest.java | 10 +-
.../java/org/apache/calcite/test/JdbcTest.java | 376 +++--
.../calcite/test/LargeGeneratedJoinTest.java | 83 +-
.../java/org/apache/calcite/test/LatticeTest.java | 14 +-
.../MaterializedViewSubstitutionVisitorTest.java | 3 +-
.../java/org/apache/calcite/test/ModelTest.java | 72 +-
.../org/apache/calcite/test/MutableRelTest.java | 6 +-
.../apache/calcite/test/ReflectiveSchemaTest.java | 25 +-
.../org/apache/calcite/test/RelBuilderTest.java | 9 +-
.../org/apache/calcite/test/RelMetadataTest.java | 27 +-
.../org/apache/calcite/test/RelOptRulesTest.java | 13 +-
.../apache/calcite/test/ScannableTableTest.java | 3 +-
.../org/apache/calcite/test/SqlFunctionsTest.java | 244 +--
.../apache/calcite/test/SqlJsonFunctionsTest.java | 4 +-
.../org/apache/calcite/test/SqlValidatorTest.java | 25 +-
.../calcite/test/fuzzer/RexProgramFuzzyTest.java | 53 +-
.../org/apache/calcite/tools/FrameworksTest.java | 3 +-
.../java/org/apache/calcite/tools/PlannerTest.java | 8 +-
.../java/org/apache/calcite/util/BitSetsTest.java | 40 +-
.../org/apache/calcite/util/ChunkListTest.java | 56 +-
.../org/apache/calcite/util/FormatModelTest.java | 15 +-
.../apache/calcite/util/ImmutableBitSetTest.java | 32 +-
.../java/org/apache/calcite/util/PairListTest.java | 12 +-
.../calcite/util/PartiallyOrderedSetTest.java | 75 +-
.../apache/calcite/util/PermutationTestCase.java | 82 +-
.../apache/calcite/util/ReflectVisitorTest.java | 33 +-
.../java/org/apache/calcite/util/SourceTest.java | 29 +-
.../java/org/apache/calcite/util/UtilTest.java | 470 +++---
.../PostgresqlDateTimeFormatterTest.java | 1733 ++++++++++----------
.../apache/calcite/util/mapping/MappingTest.java | 59 +-
.../elasticsearch/ElasticsearchJsonTest.java | 33 +-
.../elasticsearch/ElasticsearchVersionTest.java | 21 +-
.../adapter/elasticsearch/Projection2Test.java | 5 +-
.../adapter/elasticsearch/QueryBuildersTest.java | 267 +--
.../apache/calcite/test/ElasticsearchChecker.java | 12 +-
.../test/java/org/apache/calcite/test/CsvTest.java | 31 +-
.../calcite/adapter/file/CsvEnumeratorTest.java | 46 +-
.../calcite/adapter/file/FileAdapterTest.java | 43 +-
.../calcite/adapter/file/FileAdapterTests.java | 9 +-
.../calcite/adapter/file/FileReaderTest.java | 21 +-
.../calcite/adapter/geode/rel/GeodeAssertions.java | 5 +-
.../calcite/linq4j/function/FunctionTest.java | 24 +-
.../calcite/linq4j/test/BlockBuilderTest.java | 41 +-
.../apache/calcite/linq4j/test/ExpressionTest.java | 722 ++++----
.../apache/calcite/linq4j/test/InlinerTest.java | 37 +-
.../apache/calcite/linq4j/test/LimitSortTest.java | 7 +-
.../org/apache/calcite/linq4j/test/Linq4jTest.java | 523 +++---
.../apache/calcite/linq4j/test/LookupImplTest.java | 7 +-
.../apache/calcite/linq4j/test/OptimizerTest.java | 452 ++---
.../apache/calcite/linq4j/test/PrimitiveTest.java | 62 +-
.../org/apache/calcite/linq4j/tree/TypeTest.java | 17 +-
.../calcite/adapter/mongodb/MongoAdapterTest.java | 7 +-
.../org/apache/calcite/test/PigAdapterTest.java | 5 +-
.../calcite/test/PigRelBuilderStyleTest.java | 5 +-
.../apache/calcite/adapter/os/OsAdapterTest.java | 3 +-
.../java/org/apache/calcite/test/ServerTest.java | 7 +-
.../apache/calcite/sql/parser/SqlParserTest.java | 34 +-
.../apache/calcite/sql/test/AbstractSqlTester.java | 3 +-
.../apache/calcite/sql/test/ResultCheckers.java | 8 +-
.../org/apache/calcite/test/CalciteAssert.java | 10 +-
.../org/apache/calcite/test/DiffRepository.java | 6 +-
.../java/org/apache/calcite/test/DiffTestCase.java | 6 +-
.../java/org/apache/calcite/test/Matchers.java | 31 +-
.../apache/calcite/test/RelMetadataFixture.java | 13 +-
.../calcite/test/SqlOperatorFixtureImpl.java | 4 +-
.../org/apache/calcite/test/SqlOperatorTest.java | 3 +-
.../java/org/apache/calcite/util/TestUtilTest.java | 6 +-
103 files changed, 3569 insertions(+), 3462 deletions(-)
diff --git a/arrow/src/test/java/org/apache/calcite/adapter/arrow/ArrowAdapterTest.java b/arrow/src/test/java/org/apache/calcite/adapter/arrow/ArrowAdapterTest.java
index 349d85a4c4..295ae6eae6 100644
--- a/arrow/src/test/java/org/apache/calcite/adapter/arrow/ArrowAdapterTest.java
+++ b/arrow/src/test/java/org/apache/calcite/adapter/arrow/ArrowAdapterTest.java
@@ -25,7 +25,6 @@ import org.apache.calcite.test.CalciteAssert;
import org.apache.calcite.util.Bug;
import org.apache.calcite.util.Sources;
-import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import org.junit.jupiter.api.BeforeAll;
@@ -44,7 +43,9 @@ import java.nio.file.Path;
import java.sql.SQLException;
import java.util.Map;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.apache.calcite.test.Matchers.isListOf;
+
+import static org.hamcrest.MatcherAssert.assertThat;
import static java.util.Objects.requireNonNull;
@@ -87,8 +88,8 @@ class ArrowAdapterTest {
new JavaTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
RelDataType relDataType = tableMap.get("ARROWDATA").getRowType(typeFactory);
- assertEquals(relDataType.getFieldNames(),
- ImmutableList.of("intField", "stringField", "floatField", "longField"));
+ assertThat(relDataType.getFieldNames(),
+ isListOf("intField", "stringField", "floatField", "longField"));
}
@Test void testArrowProjectAllFields() {
diff --git a/build.gradle.kts b/build.gradle.kts
index 85e9d448e7..efabb1cec3 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -665,6 +665,8 @@ allprojects {
replace("hamcrest: nullValue", "org.hamcrest.Matchers.nullValue", "org.hamcrest.CoreMatchers.nullValue")
replace("hamcrest: sameInstance", "org.hamcrest.core.IsSame.sameInstance", "org.hamcrest.CoreMatchers.sameInstance")
replace("hamcrest: startsWith", "org.hamcrest.core.StringStartsWith.startsWith", "org.hamcrest.CoreMatchers.startsWith")
+ replaceRegex("hamcrest: hasToString", "\\.toString\\(\\), (is|equalTo)\\(", ", hasToString\\(")
+ replaceRegex("hamcrest: length", "\\.length, (is|equalTo)\\(", ", arrayWithSize\\(")
replaceRegex("hamcrest: size", "\\.size\\(\\), (is|equalTo)\\(", ", hasSize\\(")
replaceRegex("use static import: parseBoolean", "Boolean\\.(parseBoolean\\()", "$1")
replaceRegex("use static import: parseByte", "Byte\\.(parseByte\\()", "$1")
diff --git a/core/src/test/java/org/apache/calcite/adapter/clone/ArrayTableTest.java b/core/src/test/java/org/apache/calcite/adapter/clone/ArrayTableTest.java
index 5560ebbfb8..1f968ed648 100644
--- a/core/src/test/java/org/apache/calcite/adapter/clone/ArrayTableTest.java
+++ b/core/src/test/java/org/apache/calcite/adapter/clone/ArrayTableTest.java
@@ -27,7 +27,10 @@ import org.junit.jupiter.api.Test;
import java.util.Arrays;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.hasToString;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -39,16 +42,16 @@ class ArrayTableTest {
@Test void testPrimitiveArray() {
long[] values = {0, 0};
ArrayTable.BitSlicedPrimitiveArray.orLong(4, values, 0, 0x0F);
- assertEquals(0x0F, values[0]);
+ assertThat(values[0], is(0x0FL));
ArrayTable.BitSlicedPrimitiveArray.orLong(4, values, 2, 0x0F);
- assertEquals(0xF0F, values[0]);
+ assertThat(values[0], is(0xF0FL));
values = new long[]{
0x1213141516171819L, 0x232425262728292AL, 0x3435363738393A3BL};
- assertEquals(
- 0x324, ArrayTable.BitSlicedPrimitiveArray.getLong(12, values, 9));
- assertEquals(
- 0xa3b, ArrayTable.BitSlicedPrimitiveArray.getLong(12, values, 10));
+ assertThat(ArrayTable.BitSlicedPrimitiveArray.getLong(12, values, 9),
+ is(0x324L));
+ assertThat(ArrayTable.BitSlicedPrimitiveArray.getLong(12, values, 10),
+ is(0xa3bL));
Arrays.fill(values, 0);
for (int i = 0; i < 10; i++) {
@@ -56,35 +59,35 @@ class ArrayTableTest {
}
for (int i = 0; i < 10; i++) {
- assertEquals(
- i, ArrayTable.BitSlicedPrimitiveArray.getLong(10, values, i));
+ assertThat(ArrayTable.BitSlicedPrimitiveArray.getLong(10, values, i),
+ is((long) i));
}
}
@Test void testNextPowerOf2() {
- assertEquals(1, ColumnLoader.nextPowerOf2(1));
- assertEquals(2, ColumnLoader.nextPowerOf2(2));
- assertEquals(4, ColumnLoader.nextPowerOf2(3));
- assertEquals(4, ColumnLoader.nextPowerOf2(4));
- assertEquals(0x40000000, ColumnLoader.nextPowerOf2(0x3456789a));
- assertEquals(0x40000000, ColumnLoader.nextPowerOf2(0x40000000));
+ assertThat(ColumnLoader.nextPowerOf2(1), is(1));
+ assertThat(ColumnLoader.nextPowerOf2(2), is(2));
+ assertThat(ColumnLoader.nextPowerOf2(3), is(4));
+ assertThat(ColumnLoader.nextPowerOf2(4), is(4));
+ assertThat(ColumnLoader.nextPowerOf2(0x3456789a), is(0x40000000));
+ assertThat(ColumnLoader.nextPowerOf2(0x40000000), is(0x40000000));
// overflow
- assertEquals(0x80000000, ColumnLoader.nextPowerOf2(0x7fffffff));
- assertEquals(0x80000000, ColumnLoader.nextPowerOf2(0x7ffffffe));
+ assertThat(ColumnLoader.nextPowerOf2(0x7fffffff), is(0x80000000));
+ assertThat(ColumnLoader.nextPowerOf2(0x7ffffffe), is(0x80000000));
}
@Test void testLog2() {
- assertEquals(0, ColumnLoader.log2(0));
- assertEquals(0, ColumnLoader.log2(1));
- assertEquals(1, ColumnLoader.log2(2));
- assertEquals(2, ColumnLoader.log2(4));
- assertEquals(16, ColumnLoader.log2(65536));
- assertEquals(15, ColumnLoader.log2(65535));
- assertEquals(16, ColumnLoader.log2(65537));
- assertEquals(30, ColumnLoader.log2(Integer.MAX_VALUE));
- assertEquals(30, ColumnLoader.log2(Integer.MAX_VALUE - 1));
- assertEquals(29, ColumnLoader.log2(0x3fffffff));
- assertEquals(30, ColumnLoader.log2(0x40000000));
+ assertThat(ColumnLoader.log2(0), is(0));
+ assertThat(ColumnLoader.log2(1), is(0));
+ assertThat(ColumnLoader.log2(2), is(1));
+ assertThat(ColumnLoader.log2(4), is(2));
+ assertThat(ColumnLoader.log2(65536), is(16));
+ assertThat(ColumnLoader.log2(65535), is(15));
+ assertThat(ColumnLoader.log2(65537), is(16));
+ assertThat(ColumnLoader.log2(Integer.MAX_VALUE), is(30));
+ assertThat(ColumnLoader.log2(Integer.MAX_VALUE - 1), is(30));
+ assertThat(ColumnLoader.log2(0x3fffffff), is(29));
+ assertThat(ColumnLoader.log2(0x40000000), is(30));
}
@Test void testValueSetInt() {
@@ -97,54 +100,55 @@ class ArrayTableTest {
valueSet.add(1);
valueSet.add(10);
pair = valueSet.freeze(0, null);
- assertTrue(
- pair.representation instanceof ArrayTable.BitSlicedPrimitiveArray);
+ assertThat(pair.representation,
+ instanceOf(ArrayTable.BitSlicedPrimitiveArray.class));
representation =
(ArrayTable.BitSlicedPrimitiveArray) pair.representation;
// unsigned 4 bit integer (values 0..15)
- assertEquals(4, representation.bitCount);
+ assertThat(representation.bitCount, is(4));
assertFalse(representation.signed);
- assertEquals(0, representation.getInt(pair.dataSet, 0));
- assertEquals(1, representation.getInt(pair.dataSet, 1));
- assertEquals(10, representation.getInt(pair.dataSet, 2));
- assertEquals(10, representation.getObject(pair.dataSet, 2));
+ assertThat(representation.getInt(pair.dataSet, 0), is(0));
+ assertThat(representation.getInt(pair.dataSet, 1), is(1));
+ assertThat(representation.getInt(pair.dataSet, 2), is(10));
+ assertThat(representation.getObject(pair.dataSet, 2), is(10));
// -32 takes us to 6 bit signed
valueSet.add(-32);
pair = valueSet.freeze(0, null);
- assertTrue(
- pair.representation instanceof ArrayTable.BitSlicedPrimitiveArray);
+ assertThat(pair.representation,
+ instanceOf(ArrayTable.BitSlicedPrimitiveArray.class));
representation =
(ArrayTable.BitSlicedPrimitiveArray) pair.representation;
- assertEquals(6, representation.bitCount);
+ assertThat(representation.bitCount, is(6));
assertTrue(representation.signed);
- assertEquals(10, representation.getInt(pair.dataSet, 2));
- assertEquals(10, representation.getObject(pair.dataSet, 2));
- assertEquals(-32, representation.getInt(pair.dataSet, 3));
- assertEquals(-32, representation.getObject(pair.dataSet, 3));
+ assertThat(representation.getInt(pair.dataSet, 2), is(10));
+ assertThat(representation.getObject(pair.dataSet, 2), is(10));
+ assertThat(representation.getInt(pair.dataSet, 3), is(-32));
+ assertThat(representation.getObject(pair.dataSet, 3), is(-32));
// 63 takes us to 7 bit signed
valueSet.add(63);
pair = valueSet.freeze(0, null);
- assertTrue(
- pair.representation instanceof ArrayTable.BitSlicedPrimitiveArray);
+ assertThat(pair.representation,
+ instanceOf(ArrayTable.BitSlicedPrimitiveArray.class));
representation =
(ArrayTable.BitSlicedPrimitiveArray) pair.representation;
- assertEquals(7, representation.bitCount);
+ assertThat(representation.bitCount, is(7));
assertTrue(representation.signed);
// 128 pushes us to 8 bit signed, i.e. byte
valueSet.add(64);
pair = valueSet.freeze(0, null);
- assertTrue(pair.representation instanceof ArrayTable.PrimitiveArray);
+ assertThat(pair.representation,
+ instanceOf(ArrayTable.PrimitiveArray.class));
ArrayTable.PrimitiveArray representation2 =
(ArrayTable.PrimitiveArray) pair.representation;
- assertEquals(0, representation2.getInt(pair.dataSet, 0));
- assertEquals(-32, representation2.getInt(pair.dataSet, 3));
- assertEquals(-32, representation2.getObject(pair.dataSet, 3));
- assertEquals(64, representation2.getInt(pair.dataSet, 5));
- assertEquals(64, representation2.getObject(pair.dataSet, 5));
+ assertThat(representation2.getInt(pair.dataSet, 0), is(0));
+ assertThat(representation2.getInt(pair.dataSet, 3), is(-32));
+ assertThat(representation2.getObject(pair.dataSet, 3), is(-32));
+ assertThat(representation2.getInt(pair.dataSet, 5), is(64));
+ assertThat(representation2.getObject(pair.dataSet, 5), is(64));
}
@Test void testValueSetBoolean() {
@@ -155,16 +159,16 @@ class ArrayTableTest {
valueSet.add(1);
valueSet.add(0);
final ArrayTable.Column pair = valueSet.freeze(0, null);
- assertTrue(
- pair.representation instanceof ArrayTable.BitSlicedPrimitiveArray);
+ assertThat(pair.representation,
+ instanceOf(ArrayTable.BitSlicedPrimitiveArray.class));
final ArrayTable.BitSlicedPrimitiveArray representation =
(ArrayTable.BitSlicedPrimitiveArray) pair.representation;
- assertEquals(1, representation.bitCount);
- assertEquals(0, representation.getInt(pair.dataSet, 0));
- assertEquals(1, representation.getInt(pair.dataSet, 1));
- assertEquals(1, representation.getInt(pair.dataSet, 2));
- assertEquals(0, representation.getInt(pair.dataSet, 3));
+ assertThat(representation.bitCount, is(1));
+ assertThat(representation.getInt(pair.dataSet, 0), is(0));
+ assertThat(representation.getInt(pair.dataSet, 1), is(1));
+ assertThat(representation.getInt(pair.dataSet, 2), is(1));
+ assertThat(representation.getInt(pair.dataSet, 3), is(0));
}
@Test void testValueSetZero() {
@@ -172,12 +176,12 @@ class ArrayTableTest {
new ColumnLoader.ValueSet(boolean.class);
valueSet.add(0);
final ArrayTable.Column pair = valueSet.freeze(0, null);
- assertTrue(pair.representation instanceof ArrayTable.Constant);
+ assertThat(pair.representation, instanceOf(ArrayTable.Constant.class));
final ArrayTable.Constant representation =
(ArrayTable.Constant) pair.representation;
- assertEquals(0, representation.getInt(pair.dataSet, 0));
- assertEquals(1, pair.cardinality);
+ assertThat(representation.getInt(pair.dataSet, 0), is(0));
+ assertThat(pair.cardinality, is(1));
}
@Test void testStrings() {
@@ -188,12 +192,12 @@ class ArrayTableTest {
valueSet.add("foo");
valueSet.add("foo");
pair = valueSet.freeze(0, null);
- assertTrue(pair.representation instanceof ArrayTable.ObjectArray);
+ assertThat(pair.representation, instanceOf(ArrayTable.ObjectArray.class));
final ArrayTable.ObjectArray representation =
(ArrayTable.ObjectArray) pair.representation;
- assertEquals("foo", representation.getObject(pair.dataSet, 0));
- assertEquals("foo", representation.getObject(pair.dataSet, 1));
- assertEquals(1, pair.cardinality);
+ assertThat(representation.getObject(pair.dataSet, 0), is("foo"));
+ assertThat(representation.getObject(pair.dataSet, 1), is("foo"));
+ assertThat(pair.cardinality, is(1));
// Large number of the same string. ObjectDictionary backed by Constant.
for (int i = 0; i < 2000; i++) {
@@ -202,11 +206,11 @@ class ArrayTableTest {
pair = valueSet.freeze(0, null);
final ArrayTable.ObjectDictionary representation2 =
(ArrayTable.ObjectDictionary) pair.representation;
- assertTrue(
- representation2.representation instanceof ArrayTable.Constant);
- assertEquals("foo", representation2.getObject(pair.dataSet, 0));
- assertEquals("foo", representation2.getObject(pair.dataSet, 1000));
- assertEquals(1, pair.cardinality);
+ assertThat(representation2.representation,
+ instanceOf(ArrayTable.Constant.class));
+ assertThat(representation2.getObject(pair.dataSet, 0), is("foo"));
+ assertThat(representation2.getObject(pair.dataSet, 1000), is("foo"));
+ assertThat(pair.cardinality, is(1));
// One different string. ObjectDictionary backed by 1-bit
// BitSlicedPrimitiveArray
@@ -214,17 +218,16 @@ class ArrayTableTest {
pair = valueSet.freeze(0, null);
final ArrayTable.ObjectDictionary representation3 =
(ArrayTable.ObjectDictionary) pair.representation;
- assertTrue(
- representation3.representation
- instanceof ArrayTable.BitSlicedPrimitiveArray);
+ assertThat(representation3.representation,
+ instanceOf(ArrayTable.BitSlicedPrimitiveArray.class));
final ArrayTable.BitSlicedPrimitiveArray representation4 =
(ArrayTable.BitSlicedPrimitiveArray) representation3.representation;
- assertEquals(1, representation4.bitCount);
+ assertThat(representation4.bitCount, is(1));
assertFalse(representation4.signed);
- assertEquals("foo", representation3.getObject(pair.dataSet, 0));
- assertEquals("foo", representation3.getObject(pair.dataSet, 1000));
- assertEquals("bar", representation3.getObject(pair.dataSet, 2003));
- assertEquals(2, pair.cardinality);
+ assertThat(representation3.getObject(pair.dataSet, 0), is("foo"));
+ assertThat(representation3.getObject(pair.dataSet, 1000), is("foo"));
+ assertThat(representation3.getObject(pair.dataSet, 2003), is("bar"));
+ assertThat(pair.cardinality, is(2));
}
@Test void testAllNull() {
@@ -235,11 +238,11 @@ class ArrayTableTest {
valueSet.add(null);
pair = valueSet.freeze(0, null);
- assertTrue(pair.representation instanceof ArrayTable.ObjectArray);
+ assertThat(pair.representation, instanceOf(ArrayTable.ObjectArray.class));
final ArrayTable.ObjectArray representation =
(ArrayTable.ObjectArray) pair.representation;
assertNull(representation.getObject(pair.dataSet, 0));
- assertEquals(1, pair.cardinality);
+ assertThat(pair.cardinality, is(1));
for (int i = 0; i < 3000; i++) {
valueSet.add(null);
@@ -247,9 +250,9 @@ class ArrayTableTest {
pair = valueSet.freeze(0, null);
final ArrayTable.ObjectDictionary representation2 =
(ArrayTable.ObjectDictionary) pair.representation;
- assertTrue(
- representation2.representation instanceof ArrayTable.Constant);
- assertEquals(1, pair.cardinality);
+ assertThat(representation2.representation,
+ instanceOf(ArrayTable.Constant.class));
+ assertThat(pair.cardinality, is(1));
}
@Test void testOneValueOneNull() {
@@ -261,11 +264,11 @@ class ArrayTableTest {
valueSet.add("foo");
pair = valueSet.freeze(0, null);
- assertTrue(pair.representation instanceof ArrayTable.ObjectArray);
+ assertThat(pair.representation, instanceOf(ArrayTable.ObjectArray.class));
final ArrayTable.ObjectArray representation =
(ArrayTable.ObjectArray) pair.representation;
assertNull(representation.getObject(pair.dataSet, 0));
- assertEquals(2, pair.cardinality);
+ assertThat(pair.cardinality, is(2));
for (int i = 0; i < 3000; i++) {
valueSet.add(null);
@@ -273,13 +276,12 @@ class ArrayTableTest {
pair = valueSet.freeze(0, null);
final ArrayTable.ObjectDictionary representation2 =
(ArrayTable.ObjectDictionary) pair.representation;
- assertEquals(
- 1,
+ assertThat(
((ArrayTable.BitSlicedPrimitiveArray)
- representation2.representation).bitCount);
- assertEquals("foo", representation2.getObject(pair.dataSet, 1));
+ representation2.representation).bitCount, is(1));
+ assertThat(representation2.getObject(pair.dataSet, 1), is("foo"));
assertNull(representation2.getObject(pair.dataSet, 10));
- assertEquals(2, pair.cardinality);
+ assertThat(pair.cardinality, is(2));
}
@Test void testLoadSorted() {
@@ -356,9 +358,7 @@ class ArrayTableTest {
private void checkColumn(ArrayTable.Column x,
ArrayTable.RepresentationType expectedRepresentationType,
String expectedString) {
- assertEquals(
- expectedRepresentationType,
- x.representation.getType());
- assertEquals(expectedString, x.toString());
+ assertThat(x.representation.getType(), is(expectedRepresentationType));
+ assertThat(x, hasToString(expectedString));
}
}
diff --git a/core/src/test/java/org/apache/calcite/adapter/enumerable/EnumerableWindowTest.java b/core/src/test/java/org/apache/calcite/adapter/enumerable/EnumerableWindowTest.java
index 781f8fafa9..2af3dd3730 100644
--- a/core/src/test/java/org/apache/calcite/adapter/enumerable/EnumerableWindowTest.java
+++ b/core/src/test/java/org/apache/calcite/adapter/enumerable/EnumerableWindowTest.java
@@ -38,7 +38,8 @@ import org.junit.jupiter.api.Test;
import java.util.Collections;
import java.util.List;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.hasSize;
import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertSame;
@@ -76,9 +77,9 @@ public class EnumerableWindowTest {
final Window updated = original.copy(newConstants);
assertNotSame(original, updated);
- assertEquals(1, original.getConstants().size());
+ assertThat(original.getConstants(), hasSize(1));
assertSame(constants.get(0), original.getConstants().get(0));
- assertEquals(1, updated.getConstants().size());
+ assertThat(updated.getConstants(), hasSize(1));
assertSame(newConstants.get(0), updated.getConstants().get(0));
}
}
diff --git a/core/src/test/java/org/apache/calcite/adapter/enumerable/PhysTypeTest.java b/core/src/test/java/org/apache/calcite/adapter/enumerable/PhysTypeTest.java
index 98dc6a9cd1..494dc21a2a 100644
--- a/core/src/test/java/org/apache/calcite/adapter/enumerable/PhysTypeTest.java
+++ b/core/src/test/java/org/apache/calcite/adapter/enumerable/PhysTypeTest.java
@@ -28,7 +28,8 @@ import com.google.common.collect.ImmutableList;
import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
/**
* Test for {@link org.apache.calcite.adapter.enumerable.PhysTypeImpl}.
@@ -50,7 +51,7 @@ public final class PhysTypeTest {
PhysType rowPhysType =
PhysTypeImpl.of(TYPE_FACTORY, rowType, JavaRowFormat.ARRAY);
- assertEquals(Object[].class, rowPhysType.fieldClass(0));
+ assertThat(rowPhysType.fieldClass(0), is(Object[].class));
}
/** Test case for
@@ -68,7 +69,7 @@ public final class PhysTypeTest {
PhysType rowPhysType =
PhysTypeImpl.of(TYPE_FACTORY, rowType, JavaRowFormat.ARRAY);
- assertEquals(Object[].class, rowPhysType.fieldClass(0));
+ assertThat(rowPhysType.fieldClass(0), is(Object[].class));
}
/** Test case for
@@ -95,6 +96,6 @@ public final class PhysTypeTest {
+ " }\n"
+ "}\n"
+ ")";
- assertEquals(Expressions.toString(e), expected);
+ assertThat(expected, is(Expressions.toString(e)));
}
}
diff --git a/core/src/test/java/org/apache/calcite/interpreter/BindableWindowTest.java b/core/src/test/java/org/apache/calcite/interpreter/BindableWindowTest.java
index 3d28b3ad5d..7ebc618970 100644
--- a/core/src/test/java/org/apache/calcite/interpreter/BindableWindowTest.java
+++ b/core/src/test/java/org/apache/calcite/interpreter/BindableWindowTest.java
@@ -38,7 +38,8 @@ import org.junit.jupiter.api.Test;
import java.util.Collections;
import java.util.List;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.hasSize;
import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertSame;
@@ -76,9 +77,9 @@ public class BindableWindowTest {
final Window updated = original.copy(newConstants);
assertNotSame(original, updated);
- assertEquals(1, original.getConstants().size());
+ assertThat(original.getConstants(), hasSize(1));
assertSame(constants.get(0), original.getConstants().get(0));
- assertEquals(1, updated.getConstants().size());
+ assertThat(updated.getConstants(), hasSize(1));
assertSame(newConstants.get(0), updated.getConstants().get(0));
}
}
diff --git a/core/src/test/java/org/apache/calcite/jdbc/CalciteRemoteDriverTest.java b/core/src/test/java/org/apache/calcite/jdbc/CalciteRemoteDriverTest.java
index a7184d7c01..08432b3d01 100644
--- a/core/src/test/java/org/apache/calcite/jdbc/CalciteRemoteDriverTest.java
+++ b/core/src/test/java/org/apache/calcite/jdbc/CalciteRemoteDriverTest.java
@@ -76,6 +76,8 @@ import java.util.List;
import java.util.Locale;
import java.util.Map;
+import static org.apache.calcite.test.Matchers.primitiveArrayWithSize;
+
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
@@ -925,7 +927,7 @@ class CalciteRemoteDriverTest {
statement.addBatch(sql);
statement.addBatch(sql);
int[] updateCounts = statement.executeBatch();
- assertThat(updateCounts.length, is(2));
+ assertThat(updateCounts, primitiveArrayWithSize(2));
assertThat(updateCounts[0], is(1));
assertThat(updateCounts[1], is(1));
ResultSet resultSet = statement.getResultSet();
@@ -934,7 +936,7 @@ class CalciteRemoteDriverTest {
// Now empty batch
statement.clearBatch();
updateCounts = statement.executeBatch();
- assertThat(updateCounts.length, is(0));
+ assertThat(updateCounts, primitiveArrayWithSize(0));
resultSet = statement.getResultSet();
assertThat(resultSet, nullValue());
@@ -982,7 +984,7 @@ class CalciteRemoteDriverTest {
pst.addBatch();
int[] updateCounts = pst.executeBatch();
- assertThat(updateCounts.length, is(2));
+ assertThat(updateCounts, primitiveArrayWithSize(2));
assertThat(updateCounts[0], is(1));
assertThat(updateCounts[1], is(1));
ResultSet resultSet = pst.getResultSet();
diff --git a/core/src/test/java/org/apache/calcite/jdbc/JavaTypeFactoryTest.java b/core/src/test/java/org/apache/calcite/jdbc/JavaTypeFactoryTest.java
index 10511ea267..734f526fec 100644
--- a/core/src/test/java/org/apache/calcite/jdbc/JavaTypeFactoryTest.java
+++ b/core/src/test/java/org/apache/calcite/jdbc/JavaTypeFactoryTest.java
@@ -28,7 +28,8 @@ import java.lang.reflect.Type;
import static org.apache.calcite.linq4j.tree.Types.RecordType;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
@@ -42,7 +43,8 @@ public final class JavaTypeFactoryTest {
* Struct types with one field are not mapped correctly to Java Classes</a>. */
@Test void testGetJavaClassWithOneFieldStructDataTypeV1() {
RelDataType structWithOneField = TYPE_FACTORY.createStructType(OneFieldStruct.class);
- assertEquals(OneFieldStruct.class, TYPE_FACTORY.getJavaClass(structWithOneField));
+ assertThat(TYPE_FACTORY.getJavaClass(structWithOneField),
+ is(OneFieldStruct.class));
}
/** Test case for
@@ -61,7 +63,8 @@ public final class JavaTypeFactoryTest {
* Struct types with one field are not mapped correctly to Java Classes</a>. */
@Test void testGetJavaClassWithTwoFieldsStructDataType() {
RelDataType structWithTwoFields = TYPE_FACTORY.createStructType(TwoFieldStruct.class);
- assertEquals(TwoFieldStruct.class, TYPE_FACTORY.getJavaClass(structWithTwoFields));
+ assertThat(TYPE_FACTORY.getJavaClass(structWithTwoFields),
+ is(TwoFieldStruct.class));
}
/** Test case for
@@ -87,8 +90,8 @@ public final class JavaTypeFactoryTest {
TYPE_FACTORY.createJavaType(int.class)),
ImmutableList.of("a", "b"));
RelDataType sqlStructType = TYPE_FACTORY.toSql(javaStructType);
- assertEquals("RecordType(INTEGER a, INTEGER NOT NULL b) NOT NULL",
- SqlTests.getTypeString(sqlStructType));
+ assertThat(SqlTests.getTypeString(sqlStructType),
+ is("RecordType(INTEGER a, INTEGER NOT NULL b) NOT NULL"));
}
private void assertRecordType(Type actual) {
diff --git a/core/src/test/java/org/apache/calcite/materialize/LatticeSuggesterTest.java b/core/src/test/java/org/apache/calcite/materialize/LatticeSuggesterTest.java
index 02f26666bc..2154f1aafa 100644
--- a/core/src/test/java/org/apache/calcite/materialize/LatticeSuggesterTest.java
+++ b/core/src/test/java/org/apache/calcite/materialize/LatticeSuggesterTest.java
@@ -57,6 +57,8 @@ import java.util.stream.Collectors;
import static com.google.common.collect.ImmutableList.toImmutableList;
+import static org.apache.calcite.test.Matchers.isListOf;
+
import static org.hamcrest.CoreMatchers.allOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
@@ -599,9 +601,8 @@ class LatticeSuggesterTest {
.map(c -> (Lattice.DerivedColumn) c)
.collect(Collectors.toList());
assertThat(derivedColumns, hasSize(2));
- final List<String> tables = ImmutableList.of("customer");
- assertThat(derivedColumns.get(0).tables, is(tables));
- assertThat(derivedColumns.get(1).tables, is(tables));
+ assertThat(derivedColumns.get(0).tables, isListOf("customer"));
+ assertThat(derivedColumns.get(1).tables, isListOf("customer"));
}
/** Tests a number of features only available in Redshift: the {@code CONCAT}
diff --git a/core/src/test/java/org/apache/calcite/plan/RelOptUtilTest.java b/core/src/test/java/org/apache/calcite/plan/RelOptUtilTest.java
index 5421c8f9c2..95a33027c5 100644
--- a/core/src/test/java/org/apache/calcite/plan/RelOptUtilTest.java
+++ b/core/src/test/java/org/apache/calcite/plan/RelOptUtilTest.java
@@ -61,12 +61,13 @@ import java.util.Arrays;
import java.util.Collections;
import java.util.List;
+import static org.apache.calcite.test.Matchers.isListOf;
+
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.hasToString;
-import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.fail;
/**
@@ -207,17 +208,17 @@ class RelOptUtilTest {
* Tests the rules for how we name rules.
*/
@Test void testRuleGuessDescription() {
- assertEquals("Bar", RelOptRule.guessDescription("com.foo.Bar"));
- assertEquals("Baz", RelOptRule.guessDescription("com.flatten.Bar$Baz"));
+ assertThat(RelOptRule.guessDescription("com.foo.Bar"), is("Bar"));
+ assertThat(RelOptRule.guessDescription("com.flatten.Bar$Baz"), is("Baz"));
// yields "1" (which as an integer is an invalid
try {
Util.discard(RelOptRule.guessDescription("com.foo.Bar$1"));
fail("expected exception");
} catch (RuntimeException e) {
- assertEquals("Derived description of rule class com.foo.Bar$1 is an "
- + "integer, not valid. Supply a description manually.",
- e.getMessage());
+ assertThat(e.getMessage(),
+ is("Derived description of rule class com.foo.Bar$1 is an "
+ + "integer, not valid. Supply a description manually."));
}
}
@@ -300,10 +301,9 @@ class RelOptUtilTest {
RelOptUtil.splitJoinCondition(sysFieldList,
Arrays.asList(empScan, deptScan), joinCondition, joinKeys, null,
null);
- final List<List<RexNode>> expectedJoinKeys =
- Arrays.asList(Collections.emptyList(), Collections.emptyList());
- assertEquals(joinKeys, expectedJoinKeys);
- assertEquals(result, joinCondition);
+ assertThat(joinKeys,
+ isListOf(Collections.emptyList(), Collections.emptyList()));
+ assertThat(result, is(joinCondition));
}
/**
@@ -414,10 +414,10 @@ class RelOptUtilTest {
RelOptUtil.splitJoinCondition(empScan, deptScan, joinCond, actLeftKeys,
actRightKeys, actFilterNulls);
- assertEquals(expRemaining, actRemaining);
- assertEquals(expFilterNulls, actFilterNulls);
- assertEquals(expLeftKeys, actLeftKeys);
- assertEquals(expRightKeys, actRightKeys);
+ assertThat(actRemaining, is(expRemaining));
+ assertThat(actFilterNulls, is(expFilterNulls));
+ assertThat(actLeftKeys, is(expLeftKeys));
+ assertThat(actRightKeys, is(expRightKeys));
}
/**
@@ -562,9 +562,10 @@ class RelOptUtilTest {
.toString()));
assertThat(newJoin.getLeft(), is(instanceOf(Project.class)));
Project leftInput = (Project) newJoin.getLeft();
- assertThat(leftInput.getProjects().get(empRow.getFieldCount()).toString(),
- is(relBuilder.call(SqlStdOperatorTable.PLUS, leftKeyInputRef, relBuilder.literal(1))
- .toString()));
+ assertThat(leftInput.getProjects().get(empRow.getFieldCount()),
+ hasToString(
+ relBuilder.call(SqlStdOperatorTable.PLUS, leftKeyInputRef,
+ relBuilder.literal(1)).toString()));
}
/**
@@ -606,20 +607,21 @@ class RelOptUtilTest {
RelNode transformedInput = transformed.getInput(0);
assertThat(transformedInput, is(instanceOf(Join.class)));
Join newJoin = (Join) transformedInput;
- assertThat(newJoin.getCondition().toString(),
- is(
+ assertThat(newJoin.getCondition(),
+ hasToString(
relBuilder.call(
SqlStdOperatorTable.IS_NOT_DISTINCT_FROM,
// Computed field is added at the end (and index start at 0)
RexInputRef.of(empRow.getFieldCount(), join.getRowType()),
// Right side is shifted by 1
- RexInputRef.of(empRow.getFieldCount() + 1 + rightJoinIndex, join.getRowType()))
- .toString()));
+ RexInputRef.of(empRow.getFieldCount() + 1 + rightJoinIndex,
+ join.getRowType())).toString()));
assertThat(newJoin.getLeft(), is(instanceOf(Project.class)));
Project leftInput = (Project) newJoin.getLeft();
- assertThat(leftInput.getProjects().get(empRow.getFieldCount()).toString(),
- is(relBuilder.call(SqlStdOperatorTable.PLUS, leftKeyInputRef, relBuilder.literal(1))
- .toString()));
+ assertThat(leftInput.getProjects().get(empRow.getFieldCount()),
+ hasToString(
+ relBuilder.call(SqlStdOperatorTable.PLUS, leftKeyInputRef,
+ relBuilder.literal(1)).toString()));
}
/**
diff --git a/core/src/test/java/org/apache/calcite/plan/RelTraitTest.java b/core/src/test/java/org/apache/calcite/plan/RelTraitTest.java
index af272ea937..6a9ddbaa49 100644
--- a/core/src/test/java/org/apache/calcite/plan/RelTraitTest.java
+++ b/core/src/test/java/org/apache/calcite/plan/RelTraitTest.java
@@ -28,7 +28,9 @@ import org.junit.jupiter.api.Test;
import java.util.List;
import java.util.function.Supplier;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.hasSize;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -46,10 +48,10 @@ class RelTraitTest {
RelTrait trait1 = RelCompositeTrait.of(COLLATION, collation.get());
RelTrait trait2 = RelCompositeTrait.of(COLLATION, collation.get());
- assertEquals(
+ assertThat("RelCompositeTrait.of should return the same instance for "
+ + message,
trait1 + " @" + toHexString(identityHashCode(trait1)),
- trait2 + " @" + toHexString(identityHashCode(trait2)),
- () -> "RelCompositeTrait.of should return the same instance for " + message);
+ is(trait2 + " @" + toHexString(identityHashCode(trait2))));
}
@Test void compositeEmpty() {
@@ -69,7 +71,7 @@ class RelTraitTest {
@Test void testTraitSetDefault() {
RelTraitSet traits = RelTraitSet.createEmpty();
traits = traits.plus(Convention.NONE).plus(RelCollations.EMPTY);
- assertEquals(traits.size(), 2);
+ assertThat(traits, hasSize(2));
assertTrue(traits.isDefault());
traits = traits.replace(EnumerableConvention.INSTANCE);
assertFalse(traits.isDefault());
@@ -80,17 +82,17 @@ class RelTraitTest {
assertTrue(traits.getDefault().isDefault());
traits = traits.getDefaultSansConvention();
assertFalse(traits.isDefault());
- assertEquals(traits.getConvention(), EnumerableConvention.INSTANCE);
+ assertThat(EnumerableConvention.INSTANCE, is(traits.getConvention()));
assertTrue(traits.isDefaultSansConvention());
- assertEquals(traits.toString(), "ENUMERABLE.[]");
+ assertThat("ENUMERABLE.[]", is(traits.toString()));
}
@Test void testTraitSetEqual() {
RelTraitSet traits = RelTraitSet.createEmpty();
RelTraitSet traits1 = traits.plus(Convention.NONE).plus(RelCollations.of(0));
- assertEquals(traits1.size(), 2);
+ assertThat(traits1, hasSize(2));
RelTraitSet traits2 = traits1.replace(EnumerableConvention.INSTANCE);
- assertEquals(traits2.size(), 2);
+ assertThat(traits2, hasSize(2));
assertNotEquals(traits1, traits2);
assertTrue(traits1.equalsSansConvention(traits2));
RelTraitSet traits3 = traits2.replace(RelCollations.of(1));
diff --git a/core/src/test/java/org/apache/calcite/plan/volcano/CollationConversionTest.java b/core/src/test/java/org/apache/calcite/plan/volcano/CollationConversionTest.java
index 46a9f1747f..7dacef208a 100644
--- a/core/src/test/java/org/apache/calcite/plan/volcano/CollationConversionTest.java
+++ b/core/src/test/java/org/apache/calcite/plan/volcano/CollationConversionTest.java
@@ -48,6 +48,8 @@ import static org.apache.calcite.plan.volcano.PlannerTests.TestLeafRel;
import static org.apache.calcite.plan.volcano.PlannerTests.TestSingleRel;
import static org.apache.calcite.plan.volcano.PlannerTests.newCluster;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
@@ -82,17 +84,17 @@ class CollationConversionTest {
cluster.traitSetOf(PHYS_CALLING_CONVENTION).plus(ROOT_COLLATION));
planner.setRoot(convertedRel);
RelNode result = planner.chooseDelegate().findBestExp();
- assertTrue(result instanceof RootSingleRel);
+ assertThat(result, instanceOf(RootSingleRel.class));
assertTrue(result.getTraitSet().contains(ROOT_COLLATION));
assertTrue(result.getTraitSet().contains(PHYS_CALLING_CONVENTION));
final RelNode input = result.getInput(0);
- assertTrue(input instanceof PhysicalSort);
+ assertThat(input, instanceOf(PhysicalSort.class));
assertTrue(result.getTraitSet().contains(ROOT_COLLATION));
assertTrue(input.getTraitSet().contains(PHYS_CALLING_CONVENTION));
final RelNode input2 = input.getInput(0);
- assertTrue(input2 instanceof LeafRel);
+ assertThat(input2, instanceOf(LeafRel.class));
assertTrue(input2.getTraitSet().contains(LEAF_COLLATION));
assertTrue(input.getTraitSet().contains(PHYS_CALLING_CONVENTION));
}
diff --git a/core/src/test/java/org/apache/calcite/plan/volcano/ComboRuleTest.java b/core/src/test/java/org/apache/calcite/plan/volcano/ComboRuleTest.java
index b77b4212df..60178619c7 100644
--- a/core/src/test/java/org/apache/calcite/plan/volcano/ComboRuleTest.java
+++ b/core/src/test/java/org/apache/calcite/plan/volcano/ComboRuleTest.java
@@ -44,7 +44,8 @@ import static org.apache.calcite.plan.volcano.PlannerTests.PhysSingleRel;
import static org.apache.calcite.plan.volcano.PlannerTests.TestSingleRel;
import static org.apache.calcite.plan.volcano.PlannerTests.newCluster;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.MatcherAssert.assertThat;
/**
* Unit test for {@link VolcanoPlanner}.
@@ -68,7 +69,7 @@ class ComboRuleTest {
cluster.traitSetOf(PHYS_CALLING_CONVENTION));
planner.setRoot(convertedRel);
RelNode result = planner.chooseDelegate().findBestExp();
- assertTrue(result instanceof IntermediateNode);
+ assertThat(result, instanceOf(IntermediateNode.class));
}
/** Intermediate node, the cost decreases as it is pushed up the tree
diff --git a/core/src/test/java/org/apache/calcite/plan/volcano/MultipleTraitConversionTest.java b/core/src/test/java/org/apache/calcite/plan/volcano/MultipleTraitConversionTest.java
index 7d5853014d..0322311f14 100644
--- a/core/src/test/java/org/apache/calcite/plan/volcano/MultipleTraitConversionTest.java
+++ b/core/src/test/java/org/apache/calcite/plan/volcano/MultipleTraitConversionTest.java
@@ -37,7 +37,9 @@ import java.util.List;
import static org.apache.calcite.plan.volcano.PlannerTests.newCluster;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.hasSize;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
@@ -66,14 +68,14 @@ public class MultipleTraitConversionTest {
planner.setRoot(rel);
RelNode convertedRel = planner.changeTraitsUsingConverters(rel, toTraits);
- assertEquals(CustomTraitEnforcer.class, convertedRel.getClass());
+ assertThat(convertedRel.getClass(), is(CustomTraitEnforcer.class));
assertTrue(convertedRel.getTraitSet().satisfies(toTraits));
// Make sure that the equivalence set contains only the original and converted rels.
// It should not contain the collation enforcer, because the "from" collation already
// satisfies the "to" collation.
List<RelNode> rels = planner.getSubset(rel).set.rels;
- assertEquals(2, rels.size());
+ assertThat(rels, hasSize(2));
assertTrue(rels.stream().anyMatch(r -> r instanceof CustomLeafRel));
assertTrue(rels.stream().anyMatch(r -> r instanceof CustomTraitEnforcer));
}
diff --git a/core/src/test/java/org/apache/calcite/plan/volcano/TraitConversionTest.java b/core/src/test/java/org/apache/calcite/plan/volcano/TraitConversionTest.java
index 717557ae4b..b66d50fba9 100644
--- a/core/src/test/java/org/apache/calcite/plan/volcano/TraitConversionTest.java
+++ b/core/src/test/java/org/apache/calcite/plan/volcano/TraitConversionTest.java
@@ -41,6 +41,8 @@ import static org.apache.calcite.plan.volcano.PlannerTests.TestLeafRel;
import static org.apache.calcite.plan.volcano.PlannerTests.TestSingleRel;
import static org.apache.calcite.plan.volcano.PlannerTests.newCluster;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
@@ -76,17 +78,17 @@ class TraitConversionTest {
planner.setRoot(convertedRel);
final RelNode result = planner.chooseDelegate().findBestExp();
- assertTrue(result instanceof RandomSingleRel);
+ assertThat(result, instanceOf(RandomSingleRel.class));
assertTrue(result.getTraitSet().contains(PHYS_CALLING_CONVENTION));
assertTrue(result.getTraitSet().contains(SIMPLE_DISTRIBUTION_RANDOM));
final RelNode input = result.getInput(0);
- assertTrue(input instanceof BridgeRel);
+ assertThat(input, instanceOf(BridgeRel.class));
assertTrue(input.getTraitSet().contains(PHYS_CALLING_CONVENTION));
assertTrue(input.getTraitSet().contains(SIMPLE_DISTRIBUTION_RANDOM));
final RelNode input2 = input.getInput(0);
- assertTrue(input2 instanceof SingletonLeafRel);
+ assertThat(input2, instanceOf(SingletonLeafRel.class));
assertTrue(input2.getTraitSet().contains(PHYS_CALLING_CONVENTION));
assertTrue(input2.getTraitSet().contains(SIMPLE_DISTRIBUTION_SINGLETON));
}
diff --git a/core/src/test/java/org/apache/calcite/plan/volcano/VolcanoPlannerTest.java b/core/src/test/java/org/apache/calcite/plan/volcano/VolcanoPlannerTest.java
index 993b0d7ae3..b30464608a 100644
--- a/core/src/test/java/org/apache/calcite/plan/volcano/VolcanoPlannerTest.java
+++ b/core/src/test/java/org/apache/calcite/plan/volcano/VolcanoPlannerTest.java
@@ -73,9 +73,10 @@ import static org.apache.calcite.test.Matchers.isLinux;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.sameInstance;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.Matchers.arrayWithSize;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertSame;
@@ -109,7 +110,7 @@ class VolcanoPlannerTest {
cluster.traitSetOf(PHYS_CALLING_CONVENTION));
planner.setRoot(convertedRel);
RelNode result = planner.chooseDelegate().findBestExp();
- assertTrue(result instanceof PhysLeafRel);
+ assertThat(result, instanceOf(PhysLeafRel.class));
}
/**
@@ -137,7 +138,7 @@ class VolcanoPlannerTest {
cluster.traitSetOf(PHYS_CALLING_CONVENTION));
planner.setRoot(convertedRel);
RelNode result = planner.chooseDelegate().findBestExp();
- assertTrue(result instanceof PhysSingleRel);
+ assertThat(result, instanceOf(PhysSingleRel.class));
}
@Test void testMemoizeInputRelNodes() {
@@ -168,7 +169,7 @@ class VolcanoPlannerTest {
RelNode result = planner.chooseDelegate().findBestExp();
// Expect inputs to remain identical
- assertEquals(result.getInput(0), result.getInput(1));
+ assertThat(result.getInput(1), is(result.getInput(0)));
}
@Test void testPlanToDot() {
@@ -330,7 +331,7 @@ class VolcanoPlannerTest {
RelNode result = planner.chooseDelegate().findBestExp();
buf = config.buf();
- assertTrue(result instanceof PhysSingleRel);
+ assertThat(result, instanceOf(PhysSingleRel.class));
assertThat(sort(buf),
equalTo(
sort(
@@ -406,7 +407,7 @@ class VolcanoPlannerTest {
planner.setRoot(convertedRel);
RelNode result = planner.chooseDelegate().findBestExp();
buf = config.buf();
- assertTrue(result instanceof PhysSingleRel);
+ assertThat(result, instanceOf(PhysSingleRel.class));
assertThat(sort(buf),
equalTo(
sort("PhysSingleRel:RelSubset#0.PHYS.[]",
@@ -440,7 +441,7 @@ class VolcanoPlannerTest {
cluster.traitSetOf(PHYS_CALLING_CONVENTION));
planner.setRoot(convertedRel);
RelNode result = planner.chooseDelegate().findBestExp();
- assertTrue(result instanceof PhysSingleRel);
+ assertThat(result, instanceOf(PhysSingleRel.class));
}
private void removeTrivialProject(boolean useRule) {
@@ -479,7 +480,7 @@ class VolcanoPlannerTest {
cluster.traitSetOf(EnumerableConvention.INSTANCE));
planner.setRoot(convertedRel);
RelNode result = planner.chooseDelegate().findBestExp();
- assertTrue(result instanceof PhysToIteratorConverter);
+ assertThat(result, instanceOf(PhysToIteratorConverter.class));
}
// NOTE: this used to fail but now works
@@ -520,11 +521,9 @@ class VolcanoPlannerTest {
cluster.traitSetOf(PHYS_CALLING_CONVENTION));
planner.setRoot(convertedRel);
RelNode result = planner.chooseDelegate().findBestExp();
- assertTrue(result instanceof PhysLeafRel);
+ assertThat(result, instanceOf(PhysLeafRel.class));
PhysLeafRel resultLeaf = (PhysLeafRel) result;
- assertEquals(
- "c",
- resultLeaf.label);
+ assertThat(resultLeaf.label, is("c"));
}
/**
@@ -555,11 +554,9 @@ class VolcanoPlannerTest {
cluster.traitSetOf(PHYS_CALLING_CONVENTION));
planner.setRoot(convertedRel);
RelNode result = planner.chooseDelegate().findBestExp();
- assertTrue(result instanceof PhysLeafRel);
+ assertThat(result, instanceOf(PhysLeafRel.class));
PhysLeafRel resultLeaf = (PhysLeafRel) result;
- assertEquals(
- "c",
- resultLeaf.label);
+ assertThat(resultLeaf.label, is("c"));
}
@Test void testMergeJoin() {
@@ -657,7 +654,7 @@ class VolcanoPlannerTest {
cluster.traitSetOf(PHYS_CALLING_CONVENTION));
planner.setRoot(convertedRel);
RelNode result = planner.chooseDelegate().findBestExp();
- assertTrue(result instanceof PhysLeafRel);
+ assertThat(result, instanceOf(PhysLeafRel.class));
List<RelOptListener.RelEvent> eventList = listener.getEventList();
@@ -783,7 +780,7 @@ class VolcanoPlannerTest {
RelSubset leftRelSubset = planner.getSubset(joinRel.getInput(0));
assertNotNull(leftRelSubset);
RelNode leftParentRel = leftRelSubset.getParents().iterator().next();
- assertEquals(leftParentRel, joinSubset.getRelList().get(0));
+ assertThat(joinSubset.getRelList().get(0), is(leftParentRel));
}
/**
@@ -804,7 +801,7 @@ class VolcanoPlannerTest {
RelSubset leftRelSubset = planner.getSubset(joinRel.getInput(0));
assertNotNull(leftRelSubset);
RelNode leftParentSubset = leftRelSubset.getParentSubsets(planner).iterator().next();
- assertEquals(leftParentSubset, joinSubset);
+ assertThat(joinSubset, is(leftParentSubset));
}
private void checkEvent(
@@ -877,7 +874,7 @@ class VolcanoPlannerTest {
// Do not transform to anything; just log the calls.
TestSingleRel singleRel = call.rel(0);
RelSubset childRel = call.rel(1);
- assertThat(call.rels.length, equalTo(2));
+ assertThat(call.rels, arrayWithSize(2));
config.addBuf(singleRel.getClass().getSimpleName() + ":"
+ childRel.getDigest());
}
diff --git a/core/src/test/java/org/apache/calcite/plan/volcano/VolcanoPlannerTraitTest.java b/core/src/test/java/org/apache/calcite/plan/volcano/VolcanoPlannerTraitTest.java
index 2a6f970c95..c3e9c23a30 100644
--- a/core/src/test/java/org/apache/calcite/plan/volcano/VolcanoPlannerTraitTest.java
+++ b/core/src/test/java/org/apache/calcite/plan/volcano/VolcanoPlannerTraitTest.java
@@ -53,7 +53,9 @@ import java.util.List;
import static org.apache.calcite.plan.volcano.PlannerTests.newCluster;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -131,13 +133,10 @@ class VolcanoPlannerTraitTest {
planner.setRoot(convertedRel);
RelNode result = planner.chooseDelegate().findBestExp();
- assertTrue(result instanceof IterSingleRel);
- assertEquals(
- EnumerableConvention.INSTANCE,
- result.getTraitSet().getTrait(ConventionTraitDef.INSTANCE));
- assertEquals(
- ALT_TRAIT2,
- result.getTraitSet().getTrait(ALT_TRAIT_DEF));
+ assertThat(result, instanceOf(IterSingleRel.class));
+ assertThat(result.getTraitSet().getTrait(ConventionTraitDef.INSTANCE),
+ is(EnumerableConvention.INSTANCE));
+ assertThat(result.getTraitSet().getTrait(ALT_TRAIT_DEF), is(ALT_TRAIT2));
RelNode child = result.getInputs().get(0);
assertTrue(
@@ -150,7 +149,7 @@ class VolcanoPlannerTraitTest {
|| (child instanceof PhysToIteratorConverter));
child = child.getInputs().get(0);
- assertTrue(child instanceof PhysLeafRel);
+ assertThat(child, instanceOf(PhysLeafRel.class));
}
@Test void testRuleMatchAfterConversion() {
@@ -182,7 +181,7 @@ class VolcanoPlannerTraitTest {
planner.setRoot(convertedRel);
RelNode result = planner.chooseDelegate().findBestExp();
- assertTrue(result instanceof IterMergedRel);
+ assertThat(result, instanceOf(IterMergedRel.class));
}
@Disabled
@@ -217,22 +216,16 @@ class VolcanoPlannerTraitTest {
planner.setRoot(convertedRel);
RelNode result = planner.chooseDelegate().findBestExp();
- assertTrue(result instanceof IterSingleRel);
- assertEquals(
- EnumerableConvention.INSTANCE,
- result.getTraitSet().getTrait(ConventionTraitDef.INSTANCE));
- assertEquals(
- ALT_TRAIT2,
- result.getTraitSet().getTrait(ALT_TRAIT_DEF));
+ assertThat(result, instanceOf(IterSingleRel.class));
+ assertThat(result.getTraitSet().getTrait(ConventionTraitDef.INSTANCE),
+ is(EnumerableConvention.INSTANCE));
+ assertThat(result.getTraitSet().getTrait(ALT_TRAIT_DEF), is(ALT_TRAIT2));
RelNode child = result.getInputs().get(0);
- assertTrue(child instanceof IterSingleRel);
- assertEquals(
- EnumerableConvention.INSTANCE,
- child.getTraitSet().getTrait(ConventionTraitDef.INSTANCE));
- assertEquals(
- ALT_TRAIT2,
- child.getTraitSet().getTrait(ALT_TRAIT_DEF));
+ assertThat(child, instanceOf(IterSingleRel.class));
+ assertThat(child.getTraitSet().getTrait(ConventionTraitDef.INSTANCE),
+ is(EnumerableConvention.INSTANCE));
+ assertThat(child.getTraitSet().getTrait(ALT_TRAIT_DEF), is(ALT_TRAIT2));
child = child.getInputs().get(0);
assertTrue(
diff --git a/core/src/test/java/org/apache/calcite/prepare/LookupOperatorOverloadsTest.java b/core/src/test/java/org/apache/calcite/prepare/LookupOperatorOverloadsTest.java
index 115555515b..cd340315fe 100644
--- a/core/src/test/java/org/apache/calcite/prepare/LookupOperatorOverloadsTest.java
+++ b/core/src/test/java/org/apache/calcite/prepare/LookupOperatorOverloadsTest.java
@@ -44,7 +44,6 @@ import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
-import java.util.Arrays;
import java.util.List;
import static org.apache.calcite.sql.SqlFunctionCategory.MATCH_RECOGNIZE;
@@ -54,6 +53,7 @@ import static org.apache.calcite.sql.SqlFunctionCategory.USER_DEFINED_PROCEDURE;
import static org.apache.calcite.sql.SqlFunctionCategory.USER_DEFINED_SPECIFIC_FUNCTION;
import static org.apache.calcite.sql.SqlFunctionCategory.USER_DEFINED_TABLE_FUNCTION;
import static org.apache.calcite.sql.SqlFunctionCategory.USER_DEFINED_TABLE_SPECIFIC_FUNCTION;
+import static org.apache.calcite.test.Matchers.isListOf;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
@@ -78,7 +78,7 @@ class LookupOperatorOverloadsTest {
private static void check(List<SqlFunctionCategory> actuals,
SqlFunctionCategory... expecteds) {
- assertThat(actuals, is(Arrays.asList(expecteds)));
+ assertThat(actuals, isListOf(expecteds));
}
@Test void testIsUserDefined() {
diff --git a/core/src/test/java/org/apache/calcite/rel/logical/LogicalWindowTest.java b/core/src/test/java/org/apache/calcite/rel/logical/LogicalWindowTest.java
index 9da4865bdc..79182be959 100644
--- a/core/src/test/java/org/apache/calcite/rel/logical/LogicalWindowTest.java
+++ b/core/src/test/java/org/apache/calcite/rel/logical/LogicalWindowTest.java
@@ -40,7 +40,8 @@ import java.util.List;
import static org.apache.calcite.rel.core.Window.Group;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.hasSize;
import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertSame;
@@ -78,9 +79,9 @@ public class LogicalWindowTest {
final Window updated = original.copy(newConstants);
assertNotSame(original, updated);
- assertEquals(1, original.getConstants().size());
+ assertThat(original.getConstants(), hasSize(1));
assertSame(constants.get(0), original.getConstants().get(0));
- assertEquals(1, updated.getConstants().size());
+ assertThat(updated.getConstants(), hasSize(1));
assertSame(newConstants.get(0), updated.getConstants().get(0));
}
}
diff --git a/core/src/test/java/org/apache/calcite/rel/metadata/RelMdUtilTest.java b/core/src/test/java/org/apache/calcite/rel/metadata/RelMdUtilTest.java
index d1c7ba593f..1e14216bdc 100644
--- a/core/src/test/java/org/apache/calcite/rel/metadata/RelMdUtilTest.java
+++ b/core/src/test/java/org/apache/calcite/rel/metadata/RelMdUtilTest.java
@@ -25,10 +25,10 @@ import org.apache.calcite.tools.Frameworks;
import org.junit.jupiter.api.Test;
import static org.apache.calcite.rel.metadata.RelMdUtil.numDistinctVals;
-import static org.apache.calcite.test.Matchers.within;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.closeTo;
import static org.hamcrest.Matchers.lessThanOrEqualTo;
import static org.junit.jupiter.api.Assertions.assertFalse;
@@ -50,16 +50,16 @@ public class RelMdUtilTest {
@Test void testNumDistinctVals() {
// the first element must be distinct, the second one has half chance of being distinct
- assertThat(numDistinctVals(2.0, 2.0), within(1.5, EPSILON));
+ assertThat(numDistinctVals(2.0, 2.0), closeTo(1.5, EPSILON));
// when no selection is made, we get no distinct value
double domainSize = 100;
- assertThat(numDistinctVals(domainSize, 0.0), within(0, EPSILON));
+ assertThat(numDistinctVals(domainSize, 0.0), closeTo(0, EPSILON));
// when we perform one selection, we always have 1 distinct value,
// regardless of the domain size
for (double dSize = 1; dSize < 100; dSize += 1) {
- assertThat(numDistinctVals(dSize, 1.0), within(1.0, EPSILON));
+ assertThat(numDistinctVals(dSize, 1.0), closeTo(1.0, EPSILON));
}
// when we select n objects from a set with n values
@@ -70,11 +70,12 @@ public class RelMdUtilTest {
// when the number of selections is large enough
// we get all distinct values, w.h.p.
- assertThat(numDistinctVals(domainSize, domainSize * 100), within(domainSize, EPSILON));
+ assertThat(numDistinctVals(domainSize, domainSize * 100),
+ closeTo(domainSize, EPSILON));
- assertThat(numDistinctVals(100.0, 2.0), within(1.99, EPSILON));
- assertThat(numDistinctVals(1000.0, 2.0), within(1.999, EPSILON));
- assertThat(numDistinctVals(10000.0, 2.0), within(1.9999, EPSILON));
+ assertThat(numDistinctVals(100.0, 2.0), closeTo(1.99, EPSILON));
+ assertThat(numDistinctVals(1000.0, 2.0), closeTo(1.999, EPSILON));
+ assertThat(numDistinctVals(10000.0, 2.0), closeTo(1.9999, EPSILON));
}
@Test void testNumDistinctValsWithLargeDomain() {
@@ -90,10 +91,10 @@ public class RelMdUtilTest {
assertThat(res, lessThanOrEqualTo(numSel));
}
res = numDistinctVals(domainSize, 1.0);
- assertThat(res, within(1.0, EPSILON));
+ assertThat(res, closeTo(1.0, EPSILON));
res = numDistinctVals(domainSize, 2.0);
- assertThat(res, within(2.0, EPSILON));
+ assertThat(res, closeTo(2.0, EPSILON));
}
}
diff --git a/core/src/test/java/org/apache/calcite/rel/metadata/janino/RelMetadataHandlerGeneratorUtilTest.java b/core/src/test/java/org/apache/calcite/rel/metadata/janino/RelMetadataHandlerGeneratorUtilTest.java
index 4e908e42c9..0d74169072 100644
--- a/core/src/test/java/org/apache/calcite/rel/metadata/janino/RelMetadataHandlerGeneratorUtilTest.java
+++ b/core/src/test/java/org/apache/calcite/rel/metadata/janino/RelMetadataHandlerGeneratorUtilTest.java
@@ -35,7 +35,8 @@ import java.nio.file.Paths;
import static org.apache.calcite.linq4j.Nullness.castNonNull;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
/**
* Test {@link RelMetadataHandlerGeneratorUtil}.
@@ -154,7 +155,7 @@ class RelMetadataHandlerGeneratorUtilTest {
assert !expected.contains("\r") : "Expected code should not contain \\r";
assert !nameAndGeneratedCode.getGeneratedCode().equals("\r")
: "Generated code should not contain \\r";
- assertEquals(expected, nameAndGeneratedCode.getGeneratedCode());
+ assertThat(nameAndGeneratedCode.getGeneratedCode(), is(expected));
}
private static String readResource(String resourceName) {
diff --git a/core/src/test/java/org/apache/calcite/rex/RexBuilderTest.java b/core/src/test/java/org/apache/calcite/rex/RexBuilderTest.java
index 535232a105..da062f1634 100644
--- a/core/src/test/java/org/apache/calcite/rex/RexBuilderTest.java
+++ b/core/src/test/java/org/apache/calcite/rex/RexBuilderTest.java
@@ -63,12 +63,12 @@ import java.util.stream.Stream;
import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.hasToString;
-import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -119,7 +119,7 @@ class RexBuilderTest {
builder.ensureType(typeFactory.createSqlType(SqlTypeName.ANY), node,
true);
- assertEquals(node, ensuredNode);
+ assertThat(ensuredNode, is(node));
}
/**
@@ -136,7 +136,7 @@ class RexBuilderTest {
builder.ensureType(typeFactory.createSqlType(SqlTypeName.BOOLEAN), node,
true);
- assertEquals(node, ensuredNode);
+ assertThat(ensuredNode, is(node));
}
/**
@@ -154,7 +154,8 @@ class RexBuilderTest {
true);
assertNotEquals(node, ensuredNode);
- assertEquals(ensuredNode.getType(), typeFactory.createSqlType(SqlTypeName.INTEGER));
+ assertThat(typeFactory.createSqlType(SqlTypeName.INTEGER),
+ is(ensuredNode.getType()));
}
private static final long MOON = -14159025000L;
@@ -830,25 +831,25 @@ class RexBuilderTest {
final NlsString utf8 = new NlsString("foobar", "UTF8", SqlCollation.IMPLICIT);
RexLiteral literal = builder.makePreciseStringLiteral("foobar");
- assertEquals("'foobar'", literal.toString());
+ assertThat(literal, hasToString("'foobar'"));
literal =
builder.makePreciseStringLiteral(
new ByteString(new byte[] { 'f', 'o', 'o', 'b', 'a', 'r'}),
"UTF8", SqlCollation.IMPLICIT);
- assertEquals("_UTF8'foobar'", literal.toString());
- assertEquals("_UTF8'foobar':CHAR(6) CHARACTER SET \"UTF-8\"",
- literal.computeDigest(RexDigestIncludeType.ALWAYS));
+ assertThat(literal, hasToString("_UTF8'foobar'"));
+ assertThat(literal.computeDigest(RexDigestIncludeType.ALWAYS),
+ is("_UTF8'foobar':CHAR(6) CHARACTER SET \"UTF-8\""));
literal =
builder.makePreciseStringLiteral(
new ByteString("\u82f1\u56fd".getBytes(StandardCharsets.UTF_8)),
"UTF8", SqlCollation.IMPLICIT);
- assertEquals("_UTF8'\u82f1\u56fd'", literal.toString());
+ assertThat(literal, hasToString("_UTF8'\u82f1\u56fd'"));
// Test again to check decode cache.
literal =
builder.makePreciseStringLiteral(
new ByteString("\u82f1".getBytes(StandardCharsets.UTF_8)),
"UTF8", SqlCollation.IMPLICIT);
- assertEquals("_UTF8'\u82f1'", literal.toString());
+ assertThat(literal, hasToString("_UTF8'\u82f1'"));
try {
literal =
builder.makePreciseStringLiteral(
@@ -859,9 +860,9 @@ class RexBuilderTest {
assertThat(e.getMessage(), containsString("Failed to encode"));
}
literal = builder.makeLiteral(latin1, varchar);
- assertEquals("_LATIN1'foobar'", literal.toString());
+ assertThat(literal, hasToString("_LATIN1'foobar'"));
literal = builder.makeLiteral(utf8, varchar);
- assertEquals("_UTF8'foobar'", literal.toString());
+ assertThat(literal, hasToString("_UTF8'foobar'"));
}
/** Tests {@link RexBuilder#makeExactLiteral(java.math.BigDecimal)}. */
@@ -975,7 +976,7 @@ class RexBuilderTest {
final RexNode sarg = ((RexCall) inCall).operands.get(1);
RelDataType expected = typeFactory.createSqlType(SqlTypeName.DECIMAL, 6, 1);
- assertEquals(sarg.getType(), expected);
+ assertThat(expected, is(sarg.getType()));
}
/** Test case for
@@ -994,7 +995,7 @@ class RexBuilderTest {
final RexNode sarg = ((RexCall) betweenCall).operands.get(1);
RelDataType expected = typeFactory.createSqlType(SqlTypeName.DECIMAL, 6, 1);
- assertEquals(sarg.getType(), expected);
+ assertThat(expected, is(sarg.getType()));
}
/** Tests {@link RexCopier#visitOver(RexOver)}. */
@@ -1018,7 +1019,7 @@ class RexBuilderTest {
RexWindowBounds.CURRENT_ROW,
true, true, false, false, false);
final RexNode copy = builder.copy(node);
- assertTrue(copy instanceof RexOver);
+ assertThat(copy, instanceOf(RexOver.class));
RexOver result = (RexOver) copy;
assertThat(result.getType().getSqlTypeName(), is(SqlTypeName.VARCHAR));
@@ -1026,8 +1027,8 @@ class RexBuilderTest {
assertThat(result.getWindow(), is(node.getWindow()));
assertThat(result.getAggOperator(), is(node.getAggOperator()));
assertThat(result.getAggOperator(), is(node.getAggOperator()));
- assertEquals(node.isDistinct(), result.isDistinct());
- assertEquals(node.ignoreNulls(), result.ignoreNulls());
+ assertThat(result.isDistinct(), is(node.isDistinct()));
+ assertThat(result.ignoreNulls(), is(node.ignoreNulls()));
for (int i = 0; i < node.getOperands().size(); i++) {
assertThat(result.getOperands().get(i).getType().getSqlTypeName(),
is(node.getOperands().get(i).getType().getSqlTypeName()));
@@ -1049,7 +1050,7 @@ class RexBuilderTest {
final RexCorrelVariable node =
(RexCorrelVariable) builder.makeCorrel(type, new CorrelationId(0));
final RexNode copy = builder.copy(node);
- assertTrue(copy instanceof RexCorrelVariable);
+ assertThat(copy, instanceOf(RexCorrelVariable.class));
final RexCorrelVariable result = (RexCorrelVariable) copy;
assertThat(result.id, is(node.id));
@@ -1069,7 +1070,7 @@ class RexBuilderTest {
final RexLocalRef node = new RexLocalRef(0, type);
final RexNode copy = builder.copy(node);
- assertTrue(copy instanceof RexLocalRef);
+ assertThat(copy, instanceOf(RexLocalRef.class));
final RexLocalRef result = (RexLocalRef) copy;
assertThat(result.getIndex(), is(node.getIndex()));
@@ -1089,7 +1090,7 @@ class RexBuilderTest {
final RexDynamicParam node = builder.makeDynamicParam(type, 0);
final RexNode copy = builder.copy(node);
- assertTrue(copy instanceof RexDynamicParam);
+ assertThat(copy, instanceOf(RexDynamicParam.class));
final RexDynamicParam result = (RexDynamicParam) copy;
assertThat(result.getIndex(), is(node.getIndex()));
@@ -1109,7 +1110,7 @@ class RexBuilderTest {
final RexRangeRef node = builder.makeRangeReference(type, 1, true);
final RexNode copy = builder.copy(node);
- assertTrue(copy instanceof RexRangeRef);
+ assertThat(copy, instanceOf(RexRangeRef.class));
final RexRangeRef result = (RexRangeRef) copy;
assertThat(result.getOffset(), is(node.getOffset()));
diff --git a/core/src/test/java/org/apache/calcite/rex/RexExecutorTest.java b/core/src/test/java/org/apache/calcite/rex/RexExecutorTest.java
index 5586f2388f..eaba510d96 100644
--- a/core/src/test/java/org/apache/calcite/rex/RexExecutorTest.java
+++ b/core/src/test/java/org/apache/calcite/rex/RexExecutorTest.java
@@ -53,7 +53,6 @@ import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.hasSize;
import static org.hamcrest.Matchers.hasToString;
-import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
import static java.nio.charset.StandardCharsets.UTF_8;
@@ -105,11 +104,11 @@ class RexExecutorTest {
exec.setDataContext(testContext);
values[0] = "Hello World";
Object[] result = exec.execute();
- assertTrue(result[0] instanceof String);
+ assertThat(result[0], instanceOf(String.class));
assertThat((String) result[0], equalTo("llo World"));
values[0] = "Calcite";
result = exec.execute();
- assertTrue(result[0] instanceof String);
+ assertThat(result[0], instanceOf(String.class));
assertThat((String) result[0], equalTo("lcite"));
});
}
diff --git a/core/src/test/java/org/apache/calcite/rex/RexProgramTest.java b/core/src/test/java/org/apache/calcite/rex/RexProgramTest.java
index 70874bb9bf..1632e56a07 100644
--- a/core/src/test/java/org/apache/calcite/rex/RexProgramTest.java
+++ b/core/src/test/java/org/apache/calcite/rex/RexProgramTest.java
@@ -76,7 +76,6 @@ import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.hasSize;
import static org.hamcrest.Matchers.hasToString;
-import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotSame;
@@ -2267,8 +2266,9 @@ class RexProgramTest extends RexProgramTestBase {
}
@Test void fieldAccessEqualsHashCode() {
- assertEquals(vBool(), vBool(), "vBool() instances should be equal");
- assertEquals(vBool().hashCode(), vBool().hashCode(), "vBool().hashCode()");
+ assertThat("vBool() instances should be equal", vBool(), is(vBool()));
+ assertThat("vBool().hashCode()", vBool().hashCode(),
+ is(vBool().hashCode()));
assertNotSame(vBool(), vBool(), "vBool() is expected to produce new RexFieldAccess");
assertNotEquals(vBool(0), vBool(1), "vBool(0) != vBool(1)");
}
@@ -2285,8 +2285,10 @@ class RexProgramTest extends RexProgramTestBase {
RexCall caseNode = (RexCall) case_(condition, trueLiteral, falseLiteral);
final RexCall result = (RexCall) simplify.simplifyUnknownAs(caseNode, RexUnknownAs.UNKNOWN);
- assertThat("The case should be nonNullable", caseNode.getType().isNullable(), is(false));
- assertThat("Expected a nonNullable type", result.getType().isNullable(), is(false));
+ assertThat("The case should be nonNullable",
+ caseNode.getType().isNullable(), is(false));
+ assertThat("Expected a nonNullable type",
+ result.getType().isNullable(), is(false));
assertThat(result.getType().getSqlTypeName(), is(SqlTypeName.BOOLEAN));
assertThat(result.getOperator(), is(SqlStdOperatorTable.IS_TRUE));
assertThat(result.getOperands().get(0), is(condition));
@@ -3000,10 +3002,11 @@ class RexProgramTest extends RexProgramTestBase {
private void assertTypeAndToString(
RexNode rexNode, String representation, String type) {
- assertEquals(representation, rexNode.toString());
- assertEquals(type, rexNode.getType().toString()
- + (rexNode.getType().isNullable() ? "" : RelDataTypeImpl.NON_NULLABLE_SUFFIX),
- "type of " + rexNode);
+ assertThat(rexNode, hasToString(representation));
+ final String suffix =
+ rexNode.getType().isNullable() ? ""
+ : RelDataTypeImpl.NON_NULLABLE_SUFFIX;
+ assertThat("type of " + rexNode, rexNode.getType() + suffix, is(type));
}
@Test void testIsDeterministic() {
@@ -3012,8 +3015,8 @@ class RexProgramTest extends RexProgramTestBase {
OperandTypes.VARIADIC).withDeterministic(false);
RexNode n = rexBuilder.makeCall(ndc);
assertFalse(RexUtil.isDeterministic(n));
- assertEquals(0,
- RexUtil.retainDeterministic(RelOptUtil.conjunctions(n)).size());
+ assertThat(RexUtil.retainDeterministic(RelOptUtil.conjunctions(n)),
+ hasSize(0));
}
@Test void testConstantMap() {
diff --git a/core/src/test/java/org/apache/calcite/rex/RexProgramTestBase.java b/core/src/test/java/org/apache/calcite/rex/RexProgramTestBase.java
index 565e53d7c7..bbdd46b0e4 100644
--- a/core/src/test/java/org/apache/calcite/rex/RexProgramTestBase.java
+++ b/core/src/test/java/org/apache/calcite/rex/RexProgramTestBase.java
@@ -29,7 +29,6 @@ import org.hamcrest.Matcher;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.hasToString;
-import static org.junit.jupiter.api.Assertions.assertEquals;
import static java.util.Objects.requireNonNull;
@@ -40,10 +39,6 @@ class RexProgramTestBase extends RexProgramBuilderBase {
return new Node(rexBuilder, node);
}
- protected void checkDigest(RexNode node, String expected) {
- assertEquals(expected, node.toString(), () -> "Digest of " + node.toString());
- }
-
protected void checkCnf(RexNode node, String expected) {
assertThat("RexUtil.toCnf(rexBuilder, " + node + ")",
RexUtil.toCnf(rexBuilder, node), hasToString(expected));
@@ -82,7 +77,7 @@ class RexProgramTestBase extends RexProgramBuilderBase {
actual = node + ":" + node.getType() + (node.getType().isNullable() ? ""
: RelDataTypeImpl.NON_NULLABLE_SUFFIX);
}
- assertEquals(expected, actual, message);
+ assertThat(message, actual, is(expected));
}
/** Simplifies an expression and checks that the result is as expected. */
diff --git a/core/src/test/java/org/apache/calcite/runtime/BinarySearchTest.java b/core/src/test/java/org/apache/calcite/runtime/BinarySearchTest.java
index 395e37b89e..84cdbae0d2 100644
--- a/core/src/test/java/org/apache/calcite/runtime/BinarySearchTest.java
+++ b/core/src/test/java/org/apache/calcite/runtime/BinarySearchTest.java
@@ -23,7 +23,8 @@ import java.util.Arrays;
import static org.apache.calcite.runtime.BinarySearch.lowerBound;
import static org.apache.calcite.runtime.BinarySearch.upperBound;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
import static java.util.Comparator.naturalOrder;
@@ -32,10 +33,10 @@ import static java.util.Comparator.naturalOrder;
*/
class BinarySearchTest {
private void search(int key, int lower, int upper, Integer... array) {
- assertEquals(lower, lowerBound(array, key, naturalOrder()),
- () -> "lower bound of " + key + " in " + Arrays.toString(array));
- assertEquals(upper, upperBound(array, key, naturalOrder()),
- () -> "upper bound of " + key + " in " + Arrays.toString(array));
+ assertThat("lower bound of " + key + " in " + Arrays.toString(array),
+ lowerBound(array, key, naturalOrder()), is(lower));
+ assertThat("upper bound of " + key + " in " + Arrays.toString(array),
+ upperBound(array, key, naturalOrder()), is(upper));
}
@Test void testSimple() {
diff --git a/core/src/test/java/org/apache/calcite/runtime/SpatialTypeUtilsTest.java b/core/src/test/java/org/apache/calcite/runtime/SpatialTypeUtilsTest.java
index 1d0099fde2..9789f07032 100644
--- a/core/src/test/java/org/apache/calcite/runtime/SpatialTypeUtilsTest.java
+++ b/core/src/test/java/org/apache/calcite/runtime/SpatialTypeUtilsTest.java
@@ -21,7 +21,8 @@ import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.GeometryFactory;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
/**
* Tests {@link org.apache.calcite.runtime.SpatialTypeUtilsTest}.
@@ -30,26 +31,26 @@ class SpatialTypeUtilsTest {
@Test void testFromEwkt() {
Geometry g1 = SpatialTypeUtils.fromEwkt("POINT(1 2)");
- assertEquals(1, g1.getCoordinate().getX());
- assertEquals(2, g1.getCoordinate().getY());
+ assertThat(g1.getCoordinate().getX(), is(1D));
+ assertThat(g1.getCoordinate().getY(), is(2D));
Geometry g2 = SpatialTypeUtils.fromEwkt("srid:1234;POINT(1 2)");
- assertEquals(1234, g2.getSRID());
- assertEquals(1, g2.getCoordinate().getX());
- assertEquals(2, g2.getCoordinate().getY());
+ assertThat(g2.getSRID(), is(1234));
+ assertThat(g2.getCoordinate().getX(), is(1D));
+ assertThat(g2.getCoordinate().getY(), is(2D));
Geometry g3 = SpatialTypeUtils.fromEwkt("GEOMETRYCOLLECTION(\n"
+ " POLYGON((0 0, 3 -1, 1.5 2, 0 0)),\n"
+ " POLYGON((2 0, 3 3, 4 2, 2 0)),\n"
+ " POINT(5 6),\n"
+ " LINESTRING(1 1, 1 6))");
- assertEquals(g3.getSRID(), 0);
+ assertThat(g3.getSRID(), is(0));
}
@Test void testAsEwkt() {
GeometryFactory gf = new GeometryFactory();
Geometry g1 = gf.createPoint(new Coordinate(1, 2));
g1.setSRID(1234);
- assertEquals("srid:1234;POINT (1 2)", SpatialTypeUtils.asEwkt(g1));
+ assertThat(SpatialTypeUtils.asEwkt(g1), is("srid:1234;POINT (1 2)"));
}
}
diff --git a/core/src/test/java/org/apache/calcite/sql/test/SqlAdvisorTest.java b/core/src/test/java/org/apache/calcite/sql/test/SqlAdvisorTest.java
index fefbe34fd8..dbf250498c 100644
--- a/core/src/test/java/org/apache/calcite/sql/test/SqlAdvisorTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/test/SqlAdvisorTest.java
@@ -46,8 +46,9 @@ import java.util.function.Consumer;
import java.util.function.UnaryOperator;
import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.Matchers.hasToString;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.fail;
@@ -1548,7 +1549,7 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
}
buf.append(token).append("\n");
}
- assertEquals(expected, buf.toString());
+ assertThat(buf, hasToString(expected));
}
protected void assertHint(List<String>... expectedLists) {
@@ -1570,8 +1571,7 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
advisor.getCompletionHints(
sap.sql,
requireNonNull(sap.pos, "sap.pos"));
- assertEquals(
- expectedResults, convertCompletionHints(results));
+ assertThat(convertCompletionHints(results), is(expectedResults));
}
/**
@@ -1583,7 +1583,7 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
SqlAdvisor advisor = factory.createAdvisor();
String actual = advisor.simplifySql(sap.sql, sap.cursor);
- assertEquals(expected, actual);
+ assertThat(actual, is(expected));
return this;
}
@@ -1620,11 +1620,10 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
final String[] replaced = {null};
List<SqlMoniker> results =
advisor.getCompletionHints(sap.sql, sap.cursor, replaced);
- assertEquals(expectedResults, convertCompletionHints(results),
- () -> "Completion hints for " + sap);
+ assertThat("Completion hints for " + sap, convertCompletionHints(results),
+ is(expectedResults));
if (expectedWord != null) {
- assertEquals(expectedWord, replaced[0],
- "replaced[0] for " + sap);
+ assertThat("replaced[0] for " + sap, replaced[0], is(expectedWord));
} else {
assertNotNull(replaced[0]);
}
@@ -1645,8 +1644,8 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
}
missingReplacemenets.remove(id);
String actualReplacement = advisor.getReplacement(result, word);
- assertEquals(expectedReplacement, actualReplacement,
- () -> sap + ", replacement of " + word + " with " + id);
+ assertThat(sap + ", replacement of " + word + " with " + id,
+ actualReplacement, is(expectedReplacement));
}
if (missingReplacemenets.isEmpty()) {
return;
diff --git a/core/src/test/java/org/apache/calcite/sql/test/SqlTypeNameTest.java b/core/src/test/java/org/apache/calcite/sql/test/SqlTypeNameTest.java
index 83e6c78b48..4281179b0d 100644
--- a/core/src/test/java/org/apache/calcite/sql/test/SqlTypeNameTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/test/SqlTypeNameTest.java
@@ -43,7 +43,9 @@ import static org.apache.calcite.sql.type.SqlTypeName.TINYINT;
import static org.apache.calcite.sql.type.SqlTypeName.VARBINARY;
import static org.apache.calcite.sql.type.SqlTypeName.VARCHAR;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.nullValue;
+import static org.hamcrest.MatcherAssert.assertThat;
/**
* Tests types supported by {@link SqlTypeName}.
@@ -52,181 +54,181 @@ class SqlTypeNameTest {
@Test void testBit() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.BIT);
- assertEquals(BOOLEAN, tn, "BIT did not map to BOOLEAN");
+ assertThat("BIT did not map to BOOLEAN", tn, is(BOOLEAN));
}
@Test void testTinyint() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.TINYINT);
- assertEquals(TINYINT, tn, "TINYINT did not map to TINYINT");
+ assertThat("TINYINT did not map to TINYINT", tn, is(TINYINT));
}
@Test void testSmallint() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.SMALLINT);
- assertEquals(SMALLINT, tn, "SMALLINT did not map to SMALLINT");
+ assertThat("SMALLINT did not map to SMALLINT", tn, is(SMALLINT));
}
@Test void testInteger() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.INTEGER);
- assertEquals(INTEGER, tn, "INTEGER did not map to INTEGER");
+ assertThat("INTEGER did not map to INTEGER", tn, is(INTEGER));
}
@Test void testBigint() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.BIGINT);
- assertEquals(BIGINT, tn, "BIGINT did not map to BIGINT");
+ assertThat("BIGINT did not map to BIGINT", tn, is(BIGINT));
}
@Test void testFloat() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.FLOAT);
- assertEquals(FLOAT, tn, "FLOAT did not map to FLOAT");
+ assertThat("FLOAT did not map to FLOAT", tn, is(FLOAT));
}
@Test void testReal() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.REAL);
- assertEquals(REAL, tn, "REAL did not map to REAL");
+ assertThat("REAL did not map to REAL", tn, is(REAL));
}
@Test void testDouble() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.DOUBLE);
- assertEquals(DOUBLE, tn, "DOUBLE did not map to DOUBLE");
+ assertThat("DOUBLE did not map to DOUBLE", tn, is(DOUBLE));
}
@Test void testNumeric() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.NUMERIC);
- assertEquals(DECIMAL, tn, "NUMERIC did not map to DECIMAL");
+ assertThat("NUMERIC did not map to DECIMAL", tn, is(DECIMAL));
}
@Test void testDecimal() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.DECIMAL);
- assertEquals(DECIMAL, tn, "DECIMAL did not map to DECIMAL");
+ assertThat("DECIMAL did not map to DECIMAL", tn, is(DECIMAL));
}
@Test void testChar() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.CHAR);
- assertEquals(CHAR, tn, "CHAR did not map to CHAR");
+ assertThat("CHAR did not map to CHAR", tn, is(CHAR));
}
@Test void testVarchar() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.VARCHAR);
- assertEquals(VARCHAR, tn, "VARCHAR did not map to VARCHAR");
+ assertThat("VARCHAR did not map to VARCHAR", tn, is(VARCHAR));
}
@Test void testLongvarchar() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.LONGVARCHAR);
- assertEquals(null, tn, "LONGVARCHAR did not map to null");
+ assertThat("LONGVARCHAR did not map to null", tn, nullValue());
}
@Test void testDate() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.DATE);
- assertEquals(DATE, tn, "DATE did not map to DATE");
+ assertThat("DATE did not map to DATE", tn, is(DATE));
}
@Test void testTime() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.TIME);
- assertEquals(TIME, tn, "TIME did not map to TIME");
+ assertThat("TIME did not map to TIME", tn, is(TIME));
}
@Test void testTimestamp() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.TIMESTAMP);
- assertEquals(TIMESTAMP, tn, "TIMESTAMP did not map to TIMESTAMP");
+ assertThat("TIMESTAMP did not map to TIMESTAMP", tn, is(TIMESTAMP));
}
@Test void testBinary() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.BINARY);
- assertEquals(BINARY, tn, "BINARY did not map to BINARY");
+ assertThat("BINARY did not map to BINARY", tn, is(BINARY));
}
@Test void testVarbinary() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.VARBINARY);
- assertEquals(VARBINARY, tn, "VARBINARY did not map to VARBINARY");
+ assertThat("VARBINARY did not map to VARBINARY", tn, is(VARBINARY));
}
@Test void testLongvarbinary() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.LONGVARBINARY);
- assertEquals(null, tn, "LONGVARBINARY did not map to null");
+ assertThat("LONGVARBINARY did not map to null", tn, nullValue());
}
@Test void testNull() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.NULL);
- assertEquals(null, tn, "NULL did not map to null");
+ assertThat("NULL did not map to null", tn, nullValue());
}
@Test void testOther() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.OTHER);
- assertEquals(null, tn, "OTHER did not map to null");
+ assertThat("OTHER did not map to null", tn, nullValue());
}
@Test void testJavaobject() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.JAVA_OBJECT);
- assertEquals(null, tn, "JAVA_OBJECT did not map to null");
+ assertThat("JAVA_OBJECT did not map to null", tn, nullValue());
}
@Test void testDistinct() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.DISTINCT);
- assertEquals(DISTINCT, tn, "DISTINCT did not map to DISTINCT");
+ assertThat("DISTINCT did not map to DISTINCT", tn, is(DISTINCT));
}
@Test void testStruct() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.STRUCT);
- assertEquals(STRUCTURED, tn, "STRUCT did not map to null");
+ assertThat("STRUCT did not map to null", tn, is(STRUCTURED));
}
@Test void testArray() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.ARRAY);
- assertEquals(ARRAY, tn, "ARRAY did not map to ARRAY");
+ assertThat("ARRAY did not map to ARRAY", tn, is(ARRAY));
}
@Test void testBlob() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.BLOB);
- assertEquals(null, tn, "BLOB did not map to null");
+ assertThat("BLOB did not map to null", tn, nullValue());
}
@Test void testClob() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.CLOB);
- assertEquals(null, tn, "CLOB did not map to null");
+ assertThat("CLOB did not map to null", tn, nullValue());
}
@Test void testRef() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.REF);
- assertEquals(null, tn, "REF did not map to null");
+ assertThat("REF did not map to null", tn, nullValue());
}
@Test void testDatalink() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.DATALINK);
- assertEquals(null, tn, "DATALINK did not map to null");
+ assertThat("DATALINK did not map to null", tn, nullValue());
}
@Test void testBoolean() {
SqlTypeName tn =
SqlTypeName.getNameForJdbcType(Types.BOOLEAN);
- assertEquals(BOOLEAN, tn, "BOOLEAN did not map to BOOLEAN");
+ assertThat("BOOLEAN did not map to BOOLEAN", tn, is(BOOLEAN));
}
@Test void testRowid() {
@@ -234,7 +236,7 @@ class SqlTypeNameTest {
SqlTypeName.getNameForJdbcType(ExtraSqlTypes.ROWID);
// ROWID not supported yet
- assertEquals(null, tn, "ROWID maps to non-null type");
+ assertThat("ROWID maps to non-null type", tn, nullValue());
}
@Test void testNchar() {
@@ -242,7 +244,7 @@ class SqlTypeNameTest {
SqlTypeName.getNameForJdbcType(ExtraSqlTypes.NCHAR);
// NCHAR not supported yet, currently maps to CHAR
- assertEquals(CHAR, tn, "NCHAR did not map to CHAR");
+ assertThat("NCHAR did not map to CHAR", tn, is(CHAR));
}
@Test void testNvarchar() {
@@ -250,7 +252,7 @@ class SqlTypeNameTest {
SqlTypeName.getNameForJdbcType(ExtraSqlTypes.NVARCHAR);
// NVARCHAR not supported yet, currently maps to VARCHAR
- assertEquals(VARCHAR, tn, "NVARCHAR did not map to VARCHAR");
+ assertThat("NVARCHAR did not map to VARCHAR", tn, is(VARCHAR));
}
@Test void testLongnvarchar() {
@@ -258,7 +260,7 @@ class SqlTypeNameTest {
SqlTypeName.getNameForJdbcType(ExtraSqlTypes.LONGNVARCHAR);
// LONGNVARCHAR not supported yet
- assertEquals(null, tn, "LONGNVARCHAR maps to non-null type");
+ assertThat("LONGNVARCHAR maps to non-null type", tn, nullValue());
}
@Test void testNclob() {
@@ -266,7 +268,7 @@ class SqlTypeNameTest {
SqlTypeName.getNameForJdbcType(ExtraSqlTypes.NCLOB);
// NCLOB not supported yet
- assertEquals(null, tn, "NCLOB maps to non-null type");
+ assertThat("NCLOB maps to non-null type", tn, nullValue());
}
@Test void testSqlxml() {
@@ -274,6 +276,6 @@ class SqlTypeNameTest {
SqlTypeName.getNameForJdbcType(ExtraSqlTypes.SQLXML);
// SQLXML not supported yet
- assertEquals(null, tn, "SQLXML maps to non-null type");
+ assertThat("SQLXML maps to non-null type", tn, nullValue());
}
}
diff --git a/core/src/test/java/org/apache/calcite/sql/type/RelDataTypeSystemTest.java b/core/src/test/java/org/apache/calcite/sql/type/RelDataTypeSystemTest.java
index 5d19ae0f6a..57e691f3a0 100644
--- a/core/src/test/java/org/apache/calcite/sql/type/RelDataTypeSystemTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/type/RelDataTypeSystemTest.java
@@ -35,7 +35,6 @@ import org.junit.jupiter.api.Test;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertEquals;
/**
* Tests the inference of return types using {@code RelDataTypeSystem}.
@@ -151,14 +150,14 @@ class RelDataTypeSystemTest {
RelDataType dataType =
SqlStdOperatorTable.PLUS.inferReturnType(f,
Lists.newArrayList(operand1, operand2));
- assertEquals(12, dataType.getPrecision());
- assertEquals(2, dataType.getScale());
+ assertThat(dataType.getPrecision(), is(12));
+ assertThat(dataType.getScale(), is(2));
dataType =
SqlStdOperatorTable.MINUS.inferReturnType(f,
Lists.newArrayList(operand1, operand2));
- assertEquals(12, dataType.getPrecision());
- assertEquals(2, dataType.getScale());
+ assertThat(dataType.getPrecision(), is(12));
+ assertThat(dataType.getScale(), is(2));
}
@Test void testDecimalDivideReturnTypeInference() {
@@ -169,8 +168,8 @@ class RelDataTypeSystemTest {
RelDataType dataType =
SqlStdOperatorTable.DIVIDE.inferReturnType(f,
Lists.newArrayList(operand1, operand2));
- assertEquals(15, dataType.getPrecision());
- assertEquals(6, dataType.getScale());
+ assertThat(dataType.getPrecision(), is(15));
+ assertThat(dataType.getScale(), is(6));
}
/**
@@ -200,9 +199,9 @@ class RelDataTypeSystemTest {
RelDataType dataType = SqlStdOperatorTable.DIVIDE.inferReturnType(f, Lists
.newArrayList(operand1, operand2));
- assertEquals(SqlTypeName.DECIMAL, dataType.getSqlTypeName());
- assertEquals(28, dataType.getPrecision());
- assertEquals(6, dataType.getScale());
+ assertThat(dataType.getSqlTypeName(), is(SqlTypeName.DECIMAL));
+ assertThat(dataType.getPrecision(), is(28));
+ assertThat(dataType.getScale(), is(6));
}
@Test void testDecimalModReturnTypeInference() {
@@ -212,8 +211,8 @@ class RelDataTypeSystemTest {
RelDataType dataType = SqlStdOperatorTable.MOD.inferReturnType(f, Lists
.newArrayList(operand1, operand2));
- assertEquals(11, dataType.getPrecision());
- assertEquals(2, dataType.getScale());
+ assertThat(dataType.getPrecision(), is(11));
+ assertThat(dataType.getScale(), is(2));
}
@Test void testDoubleModReturnTypeInference() {
@@ -223,7 +222,7 @@ class RelDataTypeSystemTest {
RelDataType dataType = SqlStdOperatorTable.MOD.inferReturnType(f, Lists
.newArrayList(operand1, operand2));
- assertEquals(SqlTypeName.DOUBLE, dataType.getSqlTypeName());
+ assertThat(dataType.getSqlTypeName(), is(SqlTypeName.DOUBLE));
}
/** Tests that LEAST_RESTRICTIVE considers a MEASURE's element type
@@ -257,9 +256,9 @@ class RelDataTypeSystemTest {
RelDataType dataType = SqlStdOperatorTable.PLUS.inferReturnType(f, Lists
.newArrayList(operand1, operand2));
- assertEquals(SqlTypeName.DECIMAL, dataType.getSqlTypeName());
- assertEquals(38, dataType.getPrecision());
- assertEquals(9, dataType.getScale());
+ assertThat(dataType.getSqlTypeName(), is(SqlTypeName.DECIMAL));
+ assertThat(dataType.getPrecision(), is(38));
+ assertThat(dataType.getScale(), is(9));
}
@Test void testCustomDecimalMultiplyReturnTypeInference() {
@@ -269,9 +268,9 @@ class RelDataTypeSystemTest {
RelDataType dataType = SqlStdOperatorTable.MULTIPLY.inferReturnType(f, Lists
.newArrayList(operand1, operand2));
- assertEquals(SqlTypeName.DECIMAL, dataType.getSqlTypeName());
- assertEquals(6, dataType.getPrecision());
- assertEquals(20, dataType.getScale());
+ assertThat(dataType.getSqlTypeName(), is(SqlTypeName.DECIMAL));
+ assertThat(dataType.getPrecision(), is(6));
+ assertThat(dataType.getScale(), is(20));
}
@Test void testCustomDecimalDivideReturnTypeInference() {
@@ -281,9 +280,9 @@ class RelDataTypeSystemTest {
RelDataType dataType = SqlStdOperatorTable.DIVIDE.inferReturnType(f, Lists
.newArrayList(operand1, operand2));
- assertEquals(SqlTypeName.DECIMAL, dataType.getSqlTypeName());
- assertEquals(10, dataType.getPrecision());
- assertEquals(10, dataType.getScale());
+ assertThat(dataType.getSqlTypeName(), is(SqlTypeName.DECIMAL));
+ assertThat(dataType.getPrecision(), is(10));
+ assertThat(dataType.getScale(), is(10));
}
@Test void testCustomDecimalModReturnTypeInference() {
@@ -293,9 +292,9 @@ class RelDataTypeSystemTest {
RelDataType dataType = SqlStdOperatorTable.MOD.inferReturnType(f, Lists
.newArrayList(operand1, operand2));
- assertEquals(SqlTypeName.DECIMAL, dataType.getSqlTypeName());
- assertEquals(28, dataType.getPrecision());
- assertEquals(10, dataType.getScale());
+ assertThat(dataType.getSqlTypeName(), is(SqlTypeName.DECIMAL));
+ assertThat(dataType.getPrecision(), is(28));
+ assertThat(dataType.getScale(), is(10));
}
/** Tests that when inferring the return type for a timestamp function that takes a precision,
@@ -328,7 +327,8 @@ class RelDataTypeSystemTest {
return sqlOperand.getValueAs(clazz);
}
});
- assertEquals(SqlTypeName.TIMESTAMP, dataType.getSqlTypeName());
- assertEquals(CustomTypeSystem.CUSTOM_MAX_TIMESTAMP_PRECISION, dataType.getPrecision());
+ assertThat(dataType.getSqlTypeName(), is(SqlTypeName.TIMESTAMP));
+ assertThat(dataType.getPrecision(),
+ is(CustomTypeSystem.CUSTOM_MAX_TIMESTAMP_PRECISION));
}
}
diff --git a/core/src/test/java/org/apache/calcite/sql/type/SqlTypeUtilTest.java b/core/src/test/java/org/apache/calcite/sql/type/SqlTypeUtilTest.java
index 8fc574795f..ac0bda1b87 100644
--- a/core/src/test/java/org/apache/calcite/sql/type/SqlTypeUtilTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/type/SqlTypeUtilTest.java
@@ -29,7 +29,6 @@ import com.google.common.collect.ImmutableList;
import org.hamcrest.Matcher;
import org.junit.jupiter.api.Test;
-import java.util.Arrays;
import java.util.List;
import java.util.Locale;
import java.util.stream.Collectors;
@@ -38,6 +37,7 @@ import static org.apache.calcite.sql.type.SqlTypeUtil.areSameFamily;
import static org.apache.calcite.sql.type.SqlTypeUtil.convertTypeToSpec;
import static org.apache.calcite.sql.type.SqlTypeUtil.equalAsCollectionSansNullability;
import static org.apache.calcite.sql.type.SqlTypeUtil.equalAsMapSansNullability;
+import static org.apache.calcite.test.Matchers.isListOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
@@ -194,8 +194,8 @@ class SqlTypeUtilTest {
.map(f -> f.getTypeName().getSimple())
.collect(Collectors.toList());
assertThat(rowSpec.getTypeName().getSimple(), is("ROW"));
- assertThat(fieldNames, is(Arrays.asList("i", "j")));
- assertThat(fieldTypeNames, is(Arrays.asList("INTEGER", "INTEGER")));
+ assertThat(fieldNames, isListOf("i", "j"));
+ assertThat(fieldTypeNames, isListOf("INTEGER", "INTEGER"));
}
@Test void testGetMaxPrecisionScaleDecimal() {
diff --git a/core/src/test/java/org/apache/calcite/sql2rel/RelFieldTrimmerTest.java b/core/src/test/java/org/apache/calcite/sql2rel/RelFieldTrimmerTest.java
index 618e2d93b9..2e3b509f5a 100644
--- a/core/src/test/java/org/apache/calcite/sql2rel/RelFieldTrimmerTest.java
+++ b/core/src/test/java/org/apache/calcite/sql2rel/RelFieldTrimmerTest.java
@@ -47,6 +47,7 @@ import java.util.List;
import static org.apache.calcite.test.Matchers.hasTree;
+import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -232,11 +233,11 @@ class RelFieldTrimmerTest {
+ " LogicalTableScan(table=[[scott, DEPT]])\n";
assertThat(trimmed, hasTree(expected));
- assertTrue(original.getInput(0) instanceof Join);
+ assertThat(original.getInput(0), instanceOf(Join.class));
final Join originalJoin = (Join) original.getInput(0);
assertTrue(originalJoin.getHints().contains(noHashJoinHint));
- assertTrue(trimmed.getInput(0) instanceof Join);
+ assertThat(trimmed.getInput(0), instanceOf(Join.class));
final Join join = (Join) trimmed.getInput(0);
assertTrue(join.getHints().contains(noHashJoinHint));
}
@@ -266,11 +267,11 @@ class RelFieldTrimmerTest {
+ " LogicalTableScan(table=[[scott, EMP]])\n";
assertThat(trimmed, hasTree(expected));
- assertTrue(original instanceof Aggregate);
+ assertThat(original, instanceOf(Aggregate.class));
final Aggregate originalAggregate = (Aggregate) original;
assertTrue(originalAggregate.getHints().contains(aggHint));
- assertTrue(trimmed instanceof Aggregate);
+ assertThat(trimmed, instanceOf(Aggregate.class));
final Aggregate aggregate = (Aggregate) trimmed;
assertTrue(aggregate.getHints().contains(aggHint));
}
@@ -302,11 +303,11 @@ class RelFieldTrimmerTest {
+ " LogicalTableScan(table=[[scott, EMP]])\n";
assertThat(trimmed, hasTree(expected));
- assertTrue(original.getInput(0).getInput(0) instanceof Project);
+ assertThat(original.getInput(0).getInput(0), instanceOf(Project.class));
final Project originalProject = (Project) original.getInput(0).getInput(0);
assertTrue(originalProject.getHints().contains(projectHint));
- assertTrue(trimmed.getInput(0) instanceof Project);
+ assertThat(trimmed.getInput(0), instanceOf(Project.class));
final Project project = (Project) trimmed.getInput(0);
assertTrue(project.getHints().contains(projectHint));
}
@@ -437,15 +438,15 @@ class RelFieldTrimmerTest {
+ " LogicalTableScan(table=[[scott, EMP]])\n";
assertThat(trimmed, hasTree(expected));
- assertTrue(original.getInput(0).getInput(0) instanceof Project);
+ assertThat(original.getInput(0).getInput(0), instanceOf(Project.class));
final Project originalProject = (Project) original.getInput(0).getInput(0);
assertTrue(originalProject.getHints().contains(calcHint));
- assertTrue(relNode.getInput(0).getInput(0) instanceof Calc);
+ assertThat(relNode.getInput(0).getInput(0), instanceOf(Calc.class));
final Calc originalCalc = (Calc) relNode.getInput(0).getInput(0);
assertTrue(originalCalc.getHints().contains(calcHint));
- assertTrue(trimmed.getInput(0).getInput(0) instanceof Calc);
+ assertThat(trimmed.getInput(0).getInput(0), instanceOf(Calc.class));
final Calc calc = (Calc) trimmed.getInput(0).getInput(0);
assertTrue(calc.getHints().contains(calcHint));
}
diff --git a/core/src/test/java/org/apache/calcite/test/FilteratorTest.java b/core/src/test/java/org/apache/calcite/test/FilteratorTest.java
index a3b016996c..4ed6e5c043 100644
--- a/core/src/test/java/org/apache/calcite/test/FilteratorTest.java
+++ b/core/src/test/java/org/apache/calcite/test/FilteratorTest.java
@@ -28,7 +28,9 @@ import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.hasToString;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -46,12 +48,12 @@ class FilteratorTest {
// call hasNext twice
assertTrue(filterator.hasNext());
assertTrue(filterator.hasNext());
- assertEquals("tom", filterator.next());
+ assertThat(filterator.next(), is("tom"));
// call next without calling hasNext
- assertEquals("dick", filterator.next());
+ assertThat(filterator.next(), is("dick"));
assertTrue(filterator.hasNext());
- assertEquals("harry", filterator.next());
+ assertThat(filterator.next(), is("harry"));
assertFalse(filterator.hasNext());
assertFalse(filterator.hasNext());
}
@@ -62,8 +64,8 @@ class FilteratorTest {
final List<String> tomDickHarry = Arrays.asList("paul", null, "ringo");
final Filterator<String> filterator =
new Filterator<String>(tomDickHarry.iterator(), String.class);
- assertEquals("paul", filterator.next());
- assertEquals("ringo", filterator.next());
+ assertThat(filterator.next(), is("paul"));
+ assertThat(filterator.next(), is("ringo"));
assertFalse(filterator.hasNext());
}
@@ -85,10 +87,10 @@ class FilteratorTest {
assertTrue(filterator.hasNext());
// skips null
- assertTrue(arrayList == filterator.next());
+ assertThat(arrayList, is(filterator.next()));
// skips the HashSet
- assertTrue(linkedList == filterator.next());
+ assertThat(linkedList, is(filterator.next()));
assertFalse(filterator.hasNext());
}
@@ -98,6 +100,6 @@ class FilteratorTest {
for (int i : Util.filter(Arrays.asList(numbers), Integer.class)) {
result.add(i);
}
- assertEquals("[1, 2, 4]", result.toString());
+ assertThat(result, hasToString("[1, 2, 4]"));
}
}
diff --git a/core/src/test/java/org/apache/calcite/test/HepPlannerTest.java b/core/src/test/java/org/apache/calcite/test/HepPlannerTest.java
index 921ff70914..de1837f8b1 100644
--- a/core/src/test/java/org/apache/calcite/test/HepPlannerTest.java
+++ b/core/src/test/java/org/apache/calcite/test/HepPlannerTest.java
@@ -47,7 +47,8 @@ import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.Matchers.empty;
+import static org.hamcrest.Matchers.hasSize;
import static java.util.Objects.requireNonNull;
@@ -213,7 +214,8 @@ class HepPlannerTest {
+ "}\n"));
}
- private void assertIncludesExactlyOnce(String message, String digest, String substring) {
+ private void assertIncludesExactlyOnce(String message, String digest,
+ String substring) {
int pos = 0;
int cnt = 0;
while (pos >= 0) {
@@ -222,9 +224,9 @@ class HepPlannerTest {
cnt++;
}
}
- assertEquals(1, cnt,
- () -> message + " should include <<" + substring + ">> exactly once"
- + ", actual value is " + digest);
+ assertThat(message + " should include <<" + substring + ">> exactly once"
+ + ", actual value is " + digest,
+ cnt, is(1));
}
@Test void testMatchLimitOneTopDown() {
@@ -379,10 +381,10 @@ class HepPlannerTest {
new RelOptMaterialization(tableRel, queryRel, null,
ImmutableList.of("default", "mv"));
planner.addMaterialization(mat1);
- assertEquals(planner.getMaterializations().size(), 1);
- assertEquals(planner.getMaterializations().get(0), mat1);
+ assertThat(planner.getMaterializations(), hasSize(1));
+ assertThat(mat1, is(planner.getMaterializations().get(0)));
planner.clear();
- assertEquals(planner.getMaterializations().size(), 0);
+ assertThat(planner.getMaterializations(), empty());
}
private long checkRuleApplyCount(HepMatchOrder matchOrder) {
diff --git a/core/src/test/java/org/apache/calcite/test/InduceGroupingTypeTest.java b/core/src/test/java/org/apache/calcite/test/InduceGroupingTypeTest.java
index ef4a817f89..666ce75106 100644
--- a/core/src/test/java/org/apache/calcite/test/InduceGroupingTypeTest.java
+++ b/core/src/test/java/org/apache/calcite/test/InduceGroupingTypeTest.java
@@ -27,7 +27,6 @@ import java.util.List;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.hasToString;
-import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.fail;
/**
@@ -41,16 +40,16 @@ class InduceGroupingTypeTest {
// SIMPLE
final List<ImmutableBitSet> groupSets = new ArrayList<>();
groupSets.add(groupSet);
- assertEquals(Aggregate.Group.SIMPLE,
- Aggregate.Group.induce(groupSet, groupSets));
+ assertThat(Aggregate.Group.induce(groupSet, groupSets),
+ is(Aggregate.Group.SIMPLE));
// CUBE (has only one bit, so could also be ROLLUP)
groupSets.clear();
final ImmutableBitSet groupSet0 = ImmutableBitSet.of(2);
groupSets.add(groupSet0);
groupSets.add(ImmutableBitSet.of());
- assertEquals(Aggregate.Group.CUBE,
- Aggregate.Group.induce(groupSet0, groupSets));
+ assertThat(Aggregate.Group.induce(groupSet0, groupSets),
+ is(Aggregate.Group.CUBE));
assertThat(Aggregate.Group.isRollup(groupSet0, groupSets), is(true));
assertThat(Aggregate.Group.getRollup(groupSets),
hasToString("[2]"));
@@ -58,8 +57,8 @@ class InduceGroupingTypeTest {
// CUBE
final List<ImmutableBitSet> groupSets0 =
ImmutableBitSet.ORDERING.sortedCopy(groupSet.powerSet());
- assertEquals(Aggregate.Group.CUBE,
- Aggregate.Group.induce(groupSet, groupSets0));
+ assertThat(Aggregate.Group.induce(groupSet, groupSets0),
+ is(Aggregate.Group.CUBE));
assertThat(Aggregate.Group.isRollup(groupSet, groupSets0), is(false));
// ROLLUP
@@ -69,8 +68,8 @@ class InduceGroupingTypeTest {
groupSets.add(ImmutableBitSet.of(1, 2));
groupSets.add(ImmutableBitSet.of(1));
groupSets.add(ImmutableBitSet.of());
- assertEquals(Aggregate.Group.ROLLUP,
- Aggregate.Group.induce(groupSet, groupSets));
+ assertThat(Aggregate.Group.induce(groupSet, groupSets),
+ is(Aggregate.Group.ROLLUP));
assertThat(Aggregate.Group.isRollup(groupSet, groupSets), is(true));
assertThat(Aggregate.Group.getRollup(groupSets),
hasToString("[1, 2, 4, 5]"));
@@ -82,8 +81,8 @@ class InduceGroupingTypeTest {
groupSets.add(ImmutableBitSet.of(4, 5));
groupSets.add(ImmutableBitSet.of(4));
groupSets.add(ImmutableBitSet.of());
- assertEquals(Aggregate.Group.ROLLUP,
- Aggregate.Group.induce(groupSet, groupSets));
+ assertThat(Aggregate.Group.induce(groupSet, groupSets),
+ is(Aggregate.Group.ROLLUP));
assertThat(Aggregate.Group.getRollup(groupSets),
hasToString("[4, 5, 1, 2]"));
@@ -94,8 +93,8 @@ class InduceGroupingTypeTest {
groupSets.add(ImmutableBitSet.of(4, 5));
groupSets.add(ImmutableBitSet.of(5));
groupSets.add(ImmutableBitSet.of());
- assertEquals(Aggregate.Group.ROLLUP,
- Aggregate.Group.induce(groupSet, groupSets));
+ assertThat(Aggregate.Group.induce(groupSet, groupSets),
+ is(Aggregate.Group.ROLLUP));
assertThat(Aggregate.Group.getRollup(groupSets),
hasToString("[5, 4, 2, 1]"));
@@ -105,16 +104,16 @@ class InduceGroupingTypeTest {
groupSets.add(ImmutableBitSet.of(1, 2, 4));
groupSets.add(ImmutableBitSet.of(1, 2));
groupSets.add(ImmutableBitSet.of());
- assertEquals(Aggregate.Group.OTHER,
- Aggregate.Group.induce(groupSet, groupSets));
+ assertThat(Aggregate.Group.induce(groupSet, groupSets),
+ is(Aggregate.Group.OTHER));
groupSets.clear();
groupSets.add(ImmutableBitSet.of(1, 2, 4, 5));
groupSets.add(ImmutableBitSet.of(1, 2, 4));
groupSets.add(ImmutableBitSet.of(1, 2));
groupSets.add(ImmutableBitSet.of(1));
- assertEquals(Aggregate.Group.OTHER,
- Aggregate.Group.induce(groupSet, groupSets));
+ assertThat(Aggregate.Group.induce(groupSet, groupSets),
+ is(Aggregate.Group.OTHER));
groupSets.clear();
groupSets.add(ImmutableBitSet.of(1, 2, 4, 5));
@@ -122,8 +121,8 @@ class InduceGroupingTypeTest {
groupSets.add(ImmutableBitSet.of(1, 2));
groupSets.add(ImmutableBitSet.of(1, 4));
groupSets.add(ImmutableBitSet.of());
- assertEquals(Aggregate.Group.OTHER,
- Aggregate.Group.induce(groupSet, groupSets));
+ assertThat(Aggregate.Group.induce(groupSet, groupSets),
+ is(Aggregate.Group.OTHER));
groupSets.clear();
groupSets.add(ImmutableBitSet.of(1, 2, 5));
@@ -141,17 +140,17 @@ class InduceGroupingTypeTest {
List<ImmutableBitSet> groupSets1 =
ImmutableBitSet.ORDERING.sortedCopy(groupSets);
- assertEquals(Aggregate.Group.OTHER,
- Aggregate.Group.induce(groupSet, groupSets1));
+ assertThat(Aggregate.Group.induce(groupSet, groupSets1),
+ is(Aggregate.Group.OTHER));
groupSets.clear();
- assertEquals(Aggregate.Group.OTHER,
- Aggregate.Group.induce(groupSet, groupSets));
+ assertThat(Aggregate.Group.induce(groupSet, groupSets),
+ is(Aggregate.Group.OTHER));
groupSets.clear();
groupSets.add(ImmutableBitSet.of());
- assertEquals(Aggregate.Group.OTHER,
- Aggregate.Group.induce(groupSet, groupSets));
+ assertThat(Aggregate.Group.induce(groupSet, groupSets),
+ is(Aggregate.Group.OTHER));
}
/** Tests a singleton grouping set {2}, whose power set has only two elements,
@@ -163,22 +162,22 @@ class InduceGroupingTypeTest {
List<ImmutableBitSet> groupSets = new ArrayList<>();
groupSets.add(groupSet);
groupSets.add(ImmutableBitSet.of());
- assertEquals(Aggregate.Group.CUBE,
- Aggregate.Group.induce(groupSet, groupSets));
+ assertThat(Aggregate.Group.induce(groupSet, groupSets),
+ is(Aggregate.Group.CUBE));
groupSets = new ArrayList<>();
groupSets.add(ImmutableBitSet.of());
- assertEquals(Aggregate.Group.OTHER,
- Aggregate.Group.induce(groupSet, groupSets));
+ assertThat(Aggregate.Group.induce(groupSet, groupSets),
+ is(Aggregate.Group.OTHER));
groupSets = new ArrayList<>();
groupSets.add(groupSet);
- assertEquals(Aggregate.Group.SIMPLE,
- Aggregate.Group.induce(groupSet, groupSets));
+ assertThat(Aggregate.Group.induce(groupSet, groupSets),
+ is(Aggregate.Group.SIMPLE));
groupSets = new ArrayList<>();
- assertEquals(Aggregate.Group.OTHER,
- Aggregate.Group.induce(groupSet, groupSets));
+ assertThat(Aggregate.Group.induce(groupSet, groupSets),
+ is(Aggregate.Group.OTHER));
}
@Test void testInduceGroupingType0() {
@@ -187,11 +186,11 @@ class InduceGroupingTypeTest {
// Could be CUBE or ROLLUP but we choose SIMPLE
List<ImmutableBitSet> groupSets = new ArrayList<>();
groupSets.add(groupSet);
- assertEquals(Aggregate.Group.SIMPLE,
- Aggregate.Group.induce(groupSet, groupSets));
+ assertThat(Aggregate.Group.induce(groupSet, groupSets),
+ is(Aggregate.Group.SIMPLE));
groupSets = new ArrayList<>();
- assertEquals(Aggregate.Group.OTHER,
- Aggregate.Group.induce(groupSet, groupSets));
+ assertThat(Aggregate.Group.induce(groupSet, groupSets),
+ is(Aggregate.Group.OTHER));
}
}
diff --git a/core/src/test/java/org/apache/calcite/test/JdbcFrontJdbcBackTest.java b/core/src/test/java/org/apache/calcite/test/JdbcFrontJdbcBackTest.java
index 4293e57c0f..6fb41cdf20 100644
--- a/core/src/test/java/org/apache/calcite/test/JdbcFrontJdbcBackTest.java
+++ b/core/src/test/java/org/apache/calcite/test/JdbcFrontJdbcBackTest.java
@@ -39,7 +39,6 @@ import static org.apache.calcite.test.CalciteAssert.that;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.hasToString;
-import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -74,9 +73,20 @@ class JdbcFrontJdbcBackTest {
while (rset.next()) {
buf.append(rset.getString(3)).append(';');
}
- assertEquals(
- "account;agg_c_10_sales_fact_1997;agg_c_14_sales_fact_1997;agg_c_special_sales_fact_1997;agg_g_ms_pcat_sales_fact_1997;agg_l_03_sales_fact_1997;agg_l_04_sales_fact_1997;agg_l_05_sales_fact_1997;agg_lc_06_sales_fact_1997;agg_lc_100_sales_fact_1997;agg_ll_01_sales_fact_1997;agg_pl_01_sales_fact_1997;category;currency;customer;days;department;employee;employee_closure;expense_fact;inventory_fact_1997;inventory_fact_1998;position;product;product_class;products;promotion;regio [...]
- buf.toString());
+ assertThat(buf,
+ hasToString("account;agg_c_10_sales_fact_1997;"
+ + "agg_c_14_sales_fact_1997;agg_c_special_sales_fact_1997;"
+ + "agg_g_ms_pcat_sales_fact_1997;agg_l_03_sales_fact_1997;"
+ + "agg_l_04_sales_fact_1997;agg_l_05_sales_fact_1997;"
+ + "agg_lc_06_sales_fact_1997;agg_lc_100_sales_fact_1997;"
+ + "agg_ll_01_sales_fact_1997;agg_pl_01_sales_fact_1997;"
+ + "category;currency;customer;days;department;employee;"
+ + "employee_closure;expense_fact;inventory_fact_1997;"
+ + "inventory_fact_1998;position;product;product_class;"
+ + "products;promotion;region;reserve_employee;salary;"
+ + "sales_fact_1997;sales_fact_1998;sales_fact_dec_1998;"
+ + "store;store_ragged;time_by_day;warehouse;"
+ + "warehouse_class;COLUMNS;TABLES;"));
} catch (SQLException e) {
throw TestUtil.rethrow(e);
}
@@ -97,8 +107,8 @@ class JdbcFrontJdbcBackTest {
assertTrue(rset.next());
// Asserts that the number of columns in the result set equals
// MetaExtraTableFactoryImpl's expected number of columns.
- assertEquals(rset.getMetaData().getColumnCount(), 11);
- assertEquals(rset.getMetaData().getColumnName(11), "EXTRA_LABEL");
+ assertThat(rset.getMetaData().getColumnCount(), is(11));
+ assertThat("EXTRA_LABEL", is(rset.getMetaData().getColumnName(11)));
} catch (SQLException e) {
throw TestUtil.rethrow(e);
}
diff --git a/core/src/test/java/org/apache/calcite/test/JdbcFrontLinqBackTest.java b/core/src/test/java/org/apache/calcite/test/JdbcFrontLinqBackTest.java
index 427965c80d..95283f14d7 100644
--- a/core/src/test/java/org/apache/calcite/test/JdbcFrontLinqBackTest.java
+++ b/core/src/test/java/org/apache/calcite/test/JdbcFrontLinqBackTest.java
@@ -58,9 +58,9 @@ import static org.apache.calcite.test.CalciteAssert.that;
import static org.apache.calcite.util.ReflectUtil.isStatic;
import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* Tests for a JDBC front-end (with some quite complex SQL) and Linq4j back-end
@@ -429,9 +429,9 @@ public class JdbcFrontLinqBackTest {
boolean status = statement.execute(sql);
assertFalse(status);
ResultSet resultSet = statement.getResultSet();
- assertTrue(resultSet == null);
+ assertThat(resultSet, nullValue());
int updateCount = statement.getUpdateCount();
- assertTrue(updateCount == 1);
+ assertThat(updateCount, is(1));
}
/** Local PreparedStatement insert WITHOUT bind variables. */
@@ -446,9 +446,9 @@ public class JdbcFrontLinqBackTest {
boolean status = preparedStatement.execute();
assertFalse(status);
ResultSet resultSet = preparedStatement.getResultSet();
- assertTrue(resultSet == null);
+ assertThat(resultSet, nullValue());
int updateCount = preparedStatement.getUpdateCount();
- assertTrue(updateCount == 1);
+ assertThat(updateCount, is(1));
}
/** Local PreparedStatement insert WITH bind variables. */
diff --git a/core/src/test/java/org/apache/calcite/test/JdbcTest.java b/core/src/test/java/org/apache/calcite/test/JdbcTest.java
index 4f4838d7ab..7aaef4cf77 100644
--- a/core/src/test/java/org/apache/calcite/test/JdbcTest.java
+++ b/core/src/test/java/org/apache/calcite/test/JdbcTest.java
@@ -169,9 +169,9 @@ import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.arrayWithSize;
import static org.hamcrest.Matchers.hasSize;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
-import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -770,8 +770,8 @@ public class JdbcTest {
final Statement statement = connection.createStatement();
final ResultSet resultSet =
statement.executeQuery("select * from \"emps\"");
- assertEquals(0, closeCount[0]);
- assertEquals(0, statementCloseCount[0]);
+ assertThat(closeCount[0], is(0));
+ assertThat(statementCloseCount[0], is(0));
resultSet.close();
try {
resultSet.next();
@@ -779,8 +779,8 @@ public class JdbcTest {
} catch (SQLException e) {
assertThat(e.getMessage(), containsString("ResultSet closed"));
}
- assertEquals(0, closeCount[0]);
- assertEquals(0, statementCloseCount[0]);
+ assertThat(closeCount[0], is(0));
+ assertThat(statementCloseCount[0], is(0));
// Close statement. It throws SQLException, but statement is still closed.
try {
@@ -789,8 +789,8 @@ public class JdbcTest {
} catch (SQLException e) {
// ok
}
- assertEquals(0, closeCount[0]);
- assertEquals(1, statementCloseCount[0]);
+ assertThat(closeCount[0], is(0));
+ assertThat(statementCloseCount[0], is(1));
// Close connection. It throws SQLException, but connection is still closed.
try {
@@ -799,13 +799,13 @@ public class JdbcTest {
} catch (SQLException e) {
// ok
}
- assertEquals(1, closeCount[0]);
- assertEquals(1, statementCloseCount[0]);
+ assertThat(closeCount[0], is(1));
+ assertThat(statementCloseCount[0], is(1));
// Close a closed connection. Handler is not called again.
connection.close();
- assertEquals(1, closeCount[0]);
- assertEquals(1, statementCloseCount[0]);
+ assertThat(closeCount[0], is(1));
+ assertThat(statementCloseCount[0], is(1));
}
}
@@ -979,21 +979,21 @@ public class JdbcTest {
CalciteConnection calciteConnection =
connection.unwrap(CalciteConnection.class);
final DatabaseMetaData metaData = calciteConnection.getMetaData();
- assertEquals("Calcite JDBC Driver", metaData.getDriverName());
+ assertThat(metaData.getDriverName(), is("Calcite JDBC Driver"));
final String driverVersion = metaData.getDriverVersion();
final int driverMajor = metaData.getDriverMajorVersion();
final int driverMinor = metaData.getDriverMinorVersion();
- assertEquals(1, driverMajor);
+ assertThat(driverMajor, is(1));
assertTrue(driverMinor >= 0 && driverMinor < 40);
- assertEquals("Calcite", metaData.getDatabaseProductName());
+ assertThat(metaData.getDatabaseProductName(), is("Calcite"));
final String databaseVersion =
metaData.getDatabaseProductVersion();
final int databaseMajor = metaData.getDatabaseMajorVersion();
- assertEquals(driverMajor, databaseMajor);
+ assertThat(databaseMajor, is(driverMajor));
final int databaseMinor = metaData.getDatabaseMinorVersion();
- assertEquals(driverMinor, databaseMinor);
+ assertThat(databaseMinor, is(driverMinor));
// Check how version is composed of major and minor version. Note that
// version is stored in pom.xml; major and minor version are
@@ -1054,10 +1054,10 @@ public class JdbcTest {
ResultSet resultSet = metaData.getPrimaryKeys(null, null, null);
assertFalse(resultSet.next()); // catalog never contains primary keys
ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
- assertEquals(6, resultSetMetaData.getColumnCount());
- assertEquals("TABLE_CAT", resultSetMetaData.getColumnName(1));
- assertEquals(java.sql.Types.VARCHAR, resultSetMetaData.getColumnType(1));
- assertEquals("PK_NAME", resultSetMetaData.getColumnName(6));
+ assertThat(resultSetMetaData.getColumnCount(), is(6));
+ assertThat(resultSetMetaData.getColumnName(1), is("TABLE_CAT"));
+ assertThat(resultSetMetaData.getColumnType(1), is(Types.VARCHAR));
+ assertThat(resultSetMetaData.getColumnName(6), is("PK_NAME"));
resultSet.close();
connection.close();
}
@@ -1089,7 +1089,7 @@ public class JdbcTest {
private void checkLikeToRegex(boolean b, String pattern, String abc) {
final Pattern regex = CalciteMetaImpl.likeToRegex(Meta.Pat.of(pattern));
- assertTrue(b == regex.matcher(abc).matches());
+ assertThat(b, is(regex.matcher(abc).matches()));
}
/** Tests driver's implementation of {@link DatabaseMetaData#getColumns},
@@ -1115,16 +1115,16 @@ public class JdbcTest {
try (Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery(sql)) {
ResultSetMetaData metaData = resultSet.getMetaData();
- assertEquals(3, metaData.getColumnCount());
- assertEquals("empid", metaData.getColumnLabel(1));
- assertEquals("empid", metaData.getColumnName(1));
- assertEquals("emps", metaData.getTableName(1));
- assertEquals("X", metaData.getColumnLabel(2));
- assertEquals("deptno", metaData.getColumnName(2));
- assertEquals("emps", metaData.getTableName(2));
- assertEquals("Y", metaData.getColumnLabel(3));
- assertEquals("Y", metaData.getColumnName(3));
- assertEquals(null, metaData.getTableName(3));
+ assertThat(metaData.getColumnCount(), is(3));
+ assertThat(metaData.getColumnLabel(1), is("empid"));
+ assertThat(metaData.getColumnName(1), is("empid"));
+ assertThat(metaData.getTableName(1), is("emps"));
+ assertThat(metaData.getColumnLabel(2), is("X"));
+ assertThat(metaData.getColumnName(2), is("deptno"));
+ assertThat(metaData.getTableName(2), is("emps"));
+ assertThat(metaData.getColumnLabel(3), is("Y"));
+ assertThat(metaData.getColumnName(3), is("Y"));
+ assertThat(metaData.getTableName(3), nullValue());
}
}
@@ -1152,24 +1152,24 @@ public class JdbcTest {
+ "SELECT 1 as \"a\", 2 as \"b\", 3 as \"a\", 4 as \"B\"\n"
+ "FROM (VALUES (0))");
assertTrue(rs.next());
- assertEquals(1, rs.getInt("a"));
- assertEquals(1, rs.getInt("A"));
- assertEquals(2, rs.getInt("b"));
- assertEquals(2, rs.getInt("B"));
- assertEquals(1, rs.getInt(1));
- assertEquals(2, rs.getInt(2));
- assertEquals(3, rs.getInt(3));
- assertEquals(4, rs.getInt(4));
+ assertThat(rs.getInt("a"), is(1));
+ assertThat(rs.getInt("A"), is(1));
+ assertThat(rs.getInt("b"), is(2));
+ assertThat(rs.getInt("B"), is(2));
+ assertThat(rs.getInt(1), is(1));
+ assertThat(rs.getInt(2), is(2));
+ assertThat(rs.getInt(3), is(3));
+ assertThat(rs.getInt(4), is(4));
try {
int x = rs.getInt("z");
fail("expected error, got " + x);
} catch (SQLException e) {
// ok
}
- assertEquals(1, rs.findColumn("a"));
- assertEquals(1, rs.findColumn("A"));
- assertEquals(2, rs.findColumn("b"));
- assertEquals(2, rs.findColumn("B"));
+ assertThat(rs.findColumn("a"), is(1));
+ assertThat(rs.findColumn("A"), is(1));
+ assertThat(rs.findColumn("b"), is(2));
+ assertThat(rs.findColumn("B"), is(2));
try {
int x = rs.findColumn("z");
fail("expected error, got " + x);
@@ -1210,7 +1210,7 @@ public class JdbcTest {
statement.executeQuery(
"select count(*) from \"foodmart2\".\"time_by_day\"");
assertTrue(resultSet.next());
- assertEquals(730, resultSet.getInt(1));
+ assertThat(resultSet.getInt(1), is(730));
resultSet.close();
connection.close();
}
@@ -2168,7 +2168,7 @@ public class JdbcTest {
final String sql = "SELECT ID, VALS FROM ARR_TABLE";
ResultSet rs = calciteStatement.executeQuery(sql);
assertTrue(rs.next());
- assertEquals(1, rs.getInt(1));
+ assertThat(rs.getInt(1), is(1));
Array array = rs.getArray(2);
assertNotNull(array);
assertArrayEquals(new int[]{1, 2, 3}, (int[]) array.getArray());
@@ -2179,9 +2179,9 @@ public class JdbcTest {
calciteStatement.executeQuery("SELECT ID, CARDINALITY(VALS), VALS[2]\n"
+ "FROM ARR_TABLE");
assertTrue(rs.next());
- assertEquals(1, rs.getInt(1));
- assertEquals(3, rs.getInt(2));
- assertEquals(2, rs.getInt(3));
+ assertThat(rs.getInt(1), is(1));
+ assertThat(rs.getInt(2), is(3));
+ assertThat(rs.getInt(3), is(2));
assertFalse(rs.next());
rs.close();
@@ -2191,7 +2191,7 @@ public class JdbcTest {
assertThat(metaData.getColumnTypeName(2), is("INTEGER ARRAY"));
assertThat(metaData.getColumnTypeName(3), is("VARCHAR(10) ARRAY"));
assertTrue(rs.next());
- assertEquals(1, rs.getInt(1));
+ assertThat(rs.getInt(1), is(1));
assertThat(rs.getArray(2), notNullValue());
assertThat(rs.getArray(3), notNullValue());
assertFalse(rs.next());
@@ -2230,14 +2230,14 @@ public class JdbcTest {
is(Types.ARRAY));
final Object[] arrayValues =
(Object[]) array.getArray();
- assertThat(arrayValues.length, is(2));
+ assertThat(arrayValues, arrayWithSize(2));
final Array subArray = (Array) arrayValues[0];
assertThat(subArray.getBaseType(),
is(Types.VARCHAR));
final Object[] subArrayValues =
(Object[]) subArray.getArray();
- assertThat(subArrayValues.length, is(3));
- assertThat(subArrayValues[2], is((Object) "z"));
+ assertThat(subArrayValues, arrayWithSize(3));
+ assertThat(subArrayValues[2], is("z"));
final ResultSet subResultSet = subArray.getResultSet();
assertThat(subResultSet.next(), is(true));
@@ -5574,10 +5574,10 @@ public class JdbcTest {
statement.setMaxRows(-1);
fail("expected error");
} catch (SQLException e) {
- assertEquals(e.getMessage(), "illegal maxRows value: -1");
+ assertThat("illegal maxRows value: -1", is(e.getMessage()));
}
statement.setMaxRows(2);
- assertEquals(2, statement.getMaxRows());
+ assertThat(statement.getMaxRows(), is(2));
final ResultSet resultSet =
statement.executeQuery("select * from \"hr\".\"emps\"");
assertTrue(resultSet.next());
@@ -5622,17 +5622,16 @@ public class JdbcTest {
preparedStatement.setInt(1, 15);
preparedStatement.setString(2, "%");
resultSet = preparedStatement.executeQuery();
- assertEquals("deptno=10; name=Bill\n"
- + "deptno=10; name=Sebastian\n"
- + "deptno=10; name=Theodore\n",
- CalciteAssert.toString(resultSet));
+ assertThat(CalciteAssert.toString(resultSet),
+ is("deptno=10; name=Bill\n"
+ + "deptno=10; name=Sebastian\n"
+ + "deptno=10; name=Theodore\n"));
// execute with ?0=15 (from last bind), ?1='%r%' - 1 row
preparedStatement.setString(2, "%r%");
resultSet = preparedStatement.executeQuery();
- assertEquals(
- "deptno=10; name=Theodore\n",
- CalciteAssert.toString(resultSet));
+ assertThat(CalciteAssert.toString(resultSet),
+ is("deptno=10; name=Theodore\n"));
// Now BETWEEN, with 3 arguments, 2 of which are parameters
final String sql2 = "select \"deptno\", \"name\" "
@@ -5857,7 +5856,7 @@ public class JdbcTest {
// check that the specified 'defaultSchema' was used
that.doWithConnection(connection -> {
try {
- assertEquals("adhoc", connection.getSchema());
+ assertThat(connection.getSchema(), is("adhoc"));
} catch (SQLException e) {
throw TestUtil.rethrow(e);
}
@@ -6093,73 +6092,150 @@ public class JdbcTest {
// all table types
try (ResultSet r =
metaData.getTables(null, "adhoc", null, null)) {
- assertEquals(
- "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=EMPLOYEES; TABLE_TYPE=TABLE; REMARKS=null; TYPE_CAT=null; TYPE_SCHEM=null; TYPE_NAME=null; SELF_REFERENCING_COL_NAME=null; REF_GENERATION=null\n"
- + "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=MUTABLE_EMPLOYEES; TABLE_TYPE=TABLE; REMARKS=null; TYPE_CAT=null; TYPE_SCHEM=null; TYPE_NAME=null; SELF_REFERENCING_COL_NAME=null; REF_GENERATION=null\n"
- + "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=V; TABLE_TYPE=VIEW; REMARKS=null; TYPE_CAT=null; TYPE_SCHEM=null; TYPE_NAME=null; SELF_REFERENCING_COL_NAME=null; REF_GENERATION=null\n",
- CalciteAssert.toString(r));
+ assertThat(CalciteAssert.toString(r),
+ is("TABLE_CAT=null; TABLE_SCHEM=adhoc;"
+ + " TABLE_NAME=EMPLOYEES; TABLE_TYPE=TABLE;"
+ + " REMARKS=null; TYPE_CAT=null; TYPE_SCHEM=null;"
+ + " TYPE_NAME=null; SELF_REFERENCING_COL_NAME=null;"
+ + " REF_GENERATION=null\n"
+ + "TABLE_CAT=null; TABLE_SCHEM=adhoc;"
+ + " TABLE_NAME=MUTABLE_EMPLOYEES; TABLE_TYPE=TABLE;"
+ + " REMARKS=null; TYPE_CAT=null; TYPE_SCHEM=null;"
+ + " TYPE_NAME=null; SELF_REFERENCING_COL_NAME=null;"
+ + " REF_GENERATION=null\n"
+ + "TABLE_CAT=null; TABLE_SCHEM=adhoc;"
+ + " TABLE_NAME=V; TABLE_TYPE=VIEW;"
+ + " REMARKS=null; TYPE_CAT=null; TYPE_SCHEM=null;"
+ + " TYPE_NAME=null; SELF_REFERENCING_COL_NAME=null;"
+ + " REF_GENERATION=null\n"));
}
// including system tables; note that table type is "SYSTEM TABLE"
// not "SYSTEM_TABLE"
try (ResultSet r = metaData.getTables(null, null, null, null)) {
- assertEquals(
- "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=EMPLOYEES; TABLE_TYPE=TABLE; REMARKS=null; TYPE_CAT=null; TYPE_SCHEM=null; TYPE_NAME=null; SELF_REFERENCING_COL_NAME=null; REF_GENERATION=null\n"
- + "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=MUTABLE_EMPLOYEES; TABLE_TYPE=TABLE; REMARKS=null; TYPE_CAT=null; TYPE_SCHEM=null; TYPE_NAME=null; SELF_REFERENCING_COL_NAME=null; REF_GENERATION=null\n"
- + "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=V; TABLE_TYPE=VIEW; REMARKS=null; TYPE_CAT=null; TYPE_SCHEM=null; TYPE_NAME=null; SELF_REFERENCING_COL_NAME=null; REF_GENERATION=null\n"
- + "TABLE_CAT=null; TABLE_SCHEM=metadata; TABLE_NAME=COLUMNS; TABLE_TYPE=SYSTEM TABLE; REMARKS=null; TYPE_CAT=null; TYPE_SCHEM=null; TYPE_NAME=null; SELF_REFERENCING_COL_NAME=null; REF_GENERATION=null\n"
- + "TABLE_CAT=null; TABLE_SCHEM=metadata; TABLE_NAME=TABLES; TABLE_TYPE=SYSTEM TABLE; REMARKS=null; TYPE_CAT=null; TYPE_SCHEM=null; TYPE_NAME=null; SELF_REFERENCING_COL_NAME=null; REF_GENERATION=null\n",
- CalciteAssert.toString(r));
+ assertThat(CalciteAssert.toString(r),
+ is("TABLE_CAT=null; TABLE_SCHEM=adhoc;"
+ + " TABLE_NAME=EMPLOYEES; TABLE_TYPE=TABLE;"
+ + " REMARKS=null; TYPE_CAT=null; TYPE_SCHEM=null;"
+ + " TYPE_NAME=null; SELF_REFERENCING_COL_NAME=null;"
+ + " REF_GENERATION=null\n"
+ + "TABLE_CAT=null; TABLE_SCHEM=adhoc;"
+ + " TABLE_NAME=MUTABLE_EMPLOYEES; TABLE_TYPE=TABLE;"
+ + " REMARKS=null; TYPE_CAT=null; TYPE_SCHEM=null;"
+ + " TYPE_NAME=null; SELF_REFERENCING_COL_NAME=null;"
+ + " REF_GENERATION=null\n"
+ + "TABLE_CAT=null; TABLE_SCHEM=adhoc;"
+ + " TABLE_NAME=V; TABLE_TYPE=VIEW;"
+ + " REMARKS=null; TYPE_CAT=null; TYPE_SCHEM=null;"
+ + " TYPE_NAME=null; SELF_REFERENCING_COL_NAME=null;"
+ + " REF_GENERATION=null\n"
+ + "TABLE_CAT=null; TABLE_SCHEM=metadata;"
+ + " TABLE_NAME=COLUMNS; TABLE_TYPE=SYSTEM TABLE;"
+ + " REMARKS=null; TYPE_CAT=null; TYPE_SCHEM=null;"
+ + " TYPE_NAME=null; SELF_REFERENCING_COL_NAME=null;"
+ + " REF_GENERATION=null\n"
+ + "TABLE_CAT=null; TABLE_SCHEM=metadata;"
+ + " TABLE_NAME=TABLES; TABLE_TYPE=SYSTEM TABLE;"
+ + " REMARKS=null; TYPE_CAT=null; TYPE_SCHEM=null;"
+ + " TYPE_NAME=null; SELF_REFERENCING_COL_NAME=null;"
+ + " REF_GENERATION=null\n"));
}
// views only
try (ResultSet r =
metaData.getTables(null, "adhoc", null,
new String[]{Schema.TableType.VIEW.jdbcName})) {
- assertEquals(
- "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=V; TABLE_TYPE=VIEW; REMARKS=null; TYPE_CAT=null; TYPE_SCHEM=null; TYPE_NAME=null; SELF_REFERENCING_COL_NAME=null; REF_GENERATION=null\n",
- CalciteAssert.toString(r));
+ assertThat(CalciteAssert.toString(r),
+ is("TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=V;"
+ + " TABLE_TYPE=VIEW; REMARKS=null; TYPE_CAT=null;"
+ + " TYPE_SCHEM=null; TYPE_NAME=null;"
+ + " SELF_REFERENCING_COL_NAME=null; REF_GENERATION=null\n"));
}
// columns
try (ResultSet r =
metaData.getColumns(null, "adhoc", "V", null)) {
- assertEquals(
- "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=V; COLUMN_NAME=empid; DATA_TYPE=4; TYPE_NAME=JavaType(int) NOT NULL; COLUMN_SIZE=-1; BUFFER_LENGTH=null; DECIMAL_DIGITS=null; NUM_PREC_RADIX=10; NULLABLE=0; REMARKS=null; COLUMN_DEF=null; SQL_DATA_TYPE=null; SQL_DATETIME_SUB=null; CHAR_OCTET_LENGTH=-1; ORDINAL_POSITION=1; IS_NULLABLE=NO; SCOPE_CATALOG=null; SCOPE_SCHEMA=null; SCOPE_TABLE=null; SOURCE_DATA_TYPE=null; IS_AUTOINCREMENT=; IS_GENERATEDCOLUMN=\n"
- + "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=V; COLUMN_NAME=deptno; DATA_TYPE=4; TYPE_NAME=JavaType(int) NOT NULL; COLUMN_SIZE=-1; BUFFER_LENGTH=null; DECIMAL_DIGITS=null; NUM_PREC_RADIX=10; NULLABLE=0; REMARKS=null; COLUMN_DEF=null; SQL_DATA_TYPE=null; SQL_DATETIME_SUB=null; CHAR_OCTET_LENGTH=-1; ORDINAL_POSITION=2; IS_NULLABLE=NO; SCOPE_CATALOG=null; SCOPE_SCHEMA=null; SCOPE_TABLE=null; SOURCE_DATA_TYPE=null; IS_AUTOINCREMENT=; IS_GENERATEDCOLUMN=\n"
- + "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=V; COLUMN_NAME=name; DATA_TYPE=12; TYPE_NAME=JavaType(class java.lang.String); COLUMN_SIZE=-1; BUFFER_LENGTH=null; DECIMAL_DIGITS=null; NUM_PREC_RADIX=10; NULLABLE=1; REMARKS=null; COLUMN_DEF=null; SQL_DATA_TYPE=null; SQL_DATETIME_SUB=null; CHAR_OCTET_LENGTH=-1; ORDINAL_POSITION=3; IS_NULLABLE=YES; SCOPE_CATALOG=null; SCOPE_SCHEMA=null; SCOPE_TABLE=null; SOURCE_DATA_TYPE=null; IS_AUTOINCREMENT=; IS_GENERATEDCOLUMN=\n"
- + "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=V; COLUMN_NAME=salary; DATA_TYPE=7; TYPE_NAME=JavaType(float) NOT NULL; COLUMN_SIZE=-1; BUFFER_LENGTH=null; DECIMAL_DIGITS=null; NUM_PREC_RADIX=10; NULLABLE=0; REMARKS=null; COLUMN_DEF=null; SQL_DATA_TYPE=null; SQL_DATETIME_SUB=null; CHAR_OCTET_LENGTH=-1; ORDINAL_POSITION=4; IS_NULLABLE=NO; SCOPE_CATALOG=null; SCOPE_SCHEMA=null; SCOPE_TABLE=null; SOURCE_DATA_TYPE=null; IS_AUTOINCREMENT=; IS_GENERATEDCOLUMN=\n"
- + "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=V; COLUMN_NAME=commission; DATA_TYPE=4; TYPE_NAME=JavaType(class java.lang.Integer); COLUMN_SIZE=-1; BUFFER_LENGTH=null; DECIMAL_DIGITS=null; NUM_PREC_RADIX=10; NULLABLE=1; REMARKS=null; COLUMN_DEF=null; SQL_DATA_TYPE=null; SQL_DATETIME_SUB=null; CHAR_OCTET_LENGTH=-1; ORDINAL_POSITION=5; IS_NULLABLE=YES; SCOPE_CATALOG=null; SCOPE_SCHEMA=null; SCOPE_TABLE=null; SOURCE_DATA_TYPE=null; IS_AUTOINCREMENT=; IS_GENERATEDCOLUMN=\n",
- CalciteAssert.toString(r));
+ assertThat(CalciteAssert.toString(r),
+ is("TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=V;"
+ + " COLUMN_NAME=empid; DATA_TYPE=4;"
+ + " TYPE_NAME=JavaType(int) NOT NULL; COLUMN_SIZE=-1;"
+ + " BUFFER_LENGTH=null; DECIMAL_DIGITS=null;"
+ + " NUM_PREC_RADIX=10; NULLABLE=0; REMARKS=null;"
+ + " COLUMN_DEF=null; SQL_DATA_TYPE=null;"
+ + " SQL_DATETIME_SUB=null; CHAR_OCTET_LENGTH=-1;"
+ + " ORDINAL_POSITION=1; IS_NULLABLE=NO; SCOPE_CATALOG=null;"
+ + " SCOPE_SCHEMA=null; SCOPE_TABLE=null;"
+ + " SOURCE_DATA_TYPE=null; IS_AUTOINCREMENT=;"
+ + " IS_GENERATEDCOLUMN=\n"
+ + "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=V;"
+ + " COLUMN_NAME=deptno; DATA_TYPE=4;"
+ + " TYPE_NAME=JavaType(int) NOT NULL; COLUMN_SIZE=-1;"
+ + " BUFFER_LENGTH=null; DECIMAL_DIGITS=null;"
+ + " NUM_PREC_RADIX=10; NULLABLE=0; REMARKS=null;"
+ + " COLUMN_DEF=null; SQL_DATA_TYPE=null;"
+ + " SQL_DATETIME_SUB=null; CHAR_OCTET_LENGTH=-1;"
+ + " ORDINAL_POSITION=2; IS_NULLABLE=NO; SCOPE_CATALOG=null;"
+ + " SCOPE_SCHEMA=null; SCOPE_TABLE=null;"
+ + " SOURCE_DATA_TYPE=null; IS_AUTOINCREMENT=;"
+ + " IS_GENERATEDCOLUMN=\n"
+ + "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=V;"
+ + " COLUMN_NAME=name; DATA_TYPE=12;"
+ + " TYPE_NAME=JavaType(class java.lang.String);"
+ + " COLUMN_SIZE=-1; BUFFER_LENGTH=null; DECIMAL_DIGITS=null;"
+ + " NUM_PREC_RADIX=10; NULLABLE=1; REMARKS=null;"
+ + " COLUMN_DEF=null; SQL_DATA_TYPE=null;"
+ + " SQL_DATETIME_SUB=null; CHAR_OCTET_LENGTH=-1;"
+ + " ORDINAL_POSITION=3; IS_NULLABLE=YES; SCOPE_CATALOG=null;"
+ + " SCOPE_SCHEMA=null; SCOPE_TABLE=null;"
+ + " SOURCE_DATA_TYPE=null; IS_AUTOINCREMENT=;"
+ + " IS_GENERATEDCOLUMN=\n"
+ + "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=V;"
+ + " COLUMN_NAME=salary; DATA_TYPE=7;"
+ + " TYPE_NAME=JavaType(float) NOT NULL; COLUMN_SIZE=-1;"
+ + " BUFFER_LENGTH=null; DECIMAL_DIGITS=null;"
+ + " NUM_PREC_RADIX=10; NULLABLE=0; REMARKS=null;"
+ + " COLUMN_DEF=null; SQL_DATA_TYPE=null;"
+ + " SQL_DATETIME_SUB=null; CHAR_OCTET_LENGTH=-1;"
+ + " ORDINAL_POSITION=4; IS_NULLABLE=NO; SCOPE_CATALOG=null;"
+ + " SCOPE_SCHEMA=null; SCOPE_TABLE=null;"
+ + " SOURCE_DATA_TYPE=null; IS_AUTOINCREMENT=;"
+ + " IS_GENERATEDCOLUMN=\n"
+ + "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=V;"
+ + " COLUMN_NAME=commission; DATA_TYPE=4;"
+ + " TYPE_NAME=JavaType(class java.lang.Integer);"
+ + " COLUMN_SIZE=-1; BUFFER_LENGTH=null; DECIMAL_DIGITS=null;"
+ + " NUM_PREC_RADIX=10; NULLABLE=1; REMARKS=null;"
+ + " COLUMN_DEF=null; SQL_DATA_TYPE=null;"
+ + " SQL_DATETIME_SUB=null; CHAR_OCTET_LENGTH=-1;"
+ + " ORDINAL_POSITION=5; IS_NULLABLE=YES; SCOPE_CATALOG=null;"
+ + " SCOPE_SCHEMA=null; SCOPE_TABLE=null;"
+ + " SOURCE_DATA_TYPE=null; IS_AUTOINCREMENT=;"
+ + " IS_GENERATEDCOLUMN=\n"));
}
// catalog
try (ResultSet r = metaData.getCatalogs()) {
- assertEquals(
- "TABLE_CAT=null\n",
- CalciteAssert.toString(r));
+ assertThat(CalciteAssert.toString(r), is("TABLE_CAT=null\n"));
}
// schemas
try (ResultSet r = metaData.getSchemas()) {
- assertEquals(
- "TABLE_SCHEM=adhoc; TABLE_CATALOG=null\n"
- + "TABLE_SCHEM=metadata; TABLE_CATALOG=null\n",
- CalciteAssert.toString(r));
+ assertThat(CalciteAssert.toString(r),
+ is("TABLE_SCHEM=adhoc; TABLE_CATALOG=null\n"
+ + "TABLE_SCHEM=metadata; TABLE_CATALOG=null\n"));
}
// schemas (qualified)
try (ResultSet r = metaData.getSchemas(null, "adhoc")) {
- assertEquals(
- "TABLE_SCHEM=adhoc; TABLE_CATALOG=null\n",
- CalciteAssert.toString(r));
+ assertThat(CalciteAssert.toString(r),
+ is("TABLE_SCHEM=adhoc; TABLE_CATALOG=null\n"));
}
// table types
try (ResultSet r = metaData.getTableTypes()) {
- assertEquals("TABLE_TYPE=TABLE\n"
- + "TABLE_TYPE=VIEW\n",
- CalciteAssert.toString(r));
+ assertThat(CalciteAssert.toString(r),
+ is("TABLE_TYPE=TABLE\n"
+ + "TABLE_TYPE=VIEW\n"));
}
} catch (SQLException e) {
throw TestUtil.rethrow(e);
@@ -6569,7 +6645,7 @@ public class JdbcTest {
Statement statement = calciteConnection.createStatement();
ResultSet resultSet =
statement.executeQuery("SELECT \"myvalue\" from TEST.\"mytable2\"");
- assertEquals("myvalue=2\n", CalciteAssert.toString(resultSet));
+ assertThat(CalciteAssert.toString(resultSet), is("myvalue=2\n"));
resultSet.close();
statement.close();
connection.close();
@@ -6654,98 +6730,98 @@ public class JdbcTest {
// timestamp: 1970-01-01 00:00:00
ts = rs.getTimestamp(c); // Convert timestamp to +0100
- assertEquals(-3600000L, ts.getTime()); // 1970-01-01 00:00:00 +0100
+ assertThat(ts.getTime(), is(-3600000L));
ts = rs.getTimestamp(c, cUtc); // Convert timestamp to UTC
- assertEquals(0L, ts.getTime()); // 1970-01-01 00:00:00 +0000
+ assertThat(ts.getTime(), is(0L));
ts = rs.getTimestamp(c, cGmt03); // Convert timestamp to +0300
- assertEquals(-10800000L, ts.getTime()); // 1970-01-01 00:00:00 +0300
+ assertThat(ts.getTime(), is(-10800000L));
ts = rs.getTimestamp(c, cGmt05); // Convert timestamp to -0500
- assertEquals(18000000L, ts.getTime()); // 1970-01-01 00:00:00 -0500
+ assertThat(ts.getTime(), is(18000000L));
ts = rs.getTimestamp(c, cGmt13); // Convert timestamp to +1300
- assertEquals(-46800000, ts.getTime()); // 1970-01-01 00:00:00 +1300
+ assertThat(ts.getTime(), is(-46800000L));
s = rs.getString(c);
- assertEquals("1970-01-01 00:00:00", s);
+ assertThat(s, is("1970-01-01 00:00:00"));
++c;
if (false) {
// timestamptz: 2005-01-01 15:00:00+03
ts = rs.getTimestamp(c); // Represents an instant in
// time, TZ is irrelevant.
- assertEquals(1104580800000L, ts.getTime()); // 2005-01-01 12:00:00 UTC
+ assertThat(ts.getTime(), is(1104580800000L));
ts = rs.getTimestamp(c, cUtc); // TZ irrelevant, as above
- assertEquals(1104580800000L, ts.getTime()); // 2005-01-01 12:00:00 UTC
+ assertThat(ts.getTime(), is(1104580800000L));
ts = rs.getTimestamp(c, cGmt03); // TZ irrelevant, as above
- assertEquals(1104580800000L, ts.getTime()); // 2005-01-01 12:00:00 UTC
+ assertThat(ts.getTime(), is(1104580800000L));
ts = rs.getTimestamp(c, cGmt05); // TZ irrelevant, as above
- assertEquals(1104580800000L, ts.getTime()); // 2005-01-01 12:00:00 UTC
+ assertThat(ts.getTime(), is(1104580800000L));
ts = rs.getTimestamp(c, cGmt13); // TZ irrelevant, as above
- assertEquals(1104580800000L, ts.getTime()); // 2005-01-01 12:00:00 UTC
+ assertThat(ts.getTime(), is(1104580800000L));
++c;
}
// timestamp: 2005-01-01 15:00:00
ts = rs.getTimestamp(c); // Convert timestamp to +0100
- assertEquals(1104588000000L, ts.getTime()); // 2005-01-01 15:00:00 +0100
+ assertThat(ts.getTime(), is(1104588000000L));
ts = rs.getTimestamp(c, cUtc); // Convert timestamp to UTC
- assertEquals(1104591600000L, ts.getTime()); // 2005-01-01 15:00:00 +0000
+ assertThat(ts.getTime(), is(1104591600000L));
ts = rs.getTimestamp(c, cGmt03); // Convert timestamp to +0300
- assertEquals(1104580800000L, ts.getTime()); // 2005-01-01 15:00:00 +0300
+ assertThat(ts.getTime(), is(1104580800000L));
ts = rs.getTimestamp(c, cGmt05); // Convert timestamp to -0500
- assertEquals(1104609600000L, ts.getTime()); // 2005-01-01 15:00:00 -0500
+ assertThat(ts.getTime(), is(1104609600000L));
ts = rs.getTimestamp(c, cGmt13); // Convert timestamp to +1300
- assertEquals(1104544800000L, ts.getTime()); // 2005-01-01 15:00:00 +1300
+ assertThat(ts.getTime(), is(1104544800000L));
s = rs.getString(c);
- assertEquals("2005-01-01 15:00:00", s);
+ assertThat(s, is("2005-01-01 15:00:00"));
++c;
// time: 15:00:00
ts = rs.getTimestamp(c);
- assertEquals(50400000L, ts.getTime()); // 1970-01-01 15:00:00 +0100
+ assertThat(ts.getTime(), is(50400000L));
ts = rs.getTimestamp(c, cUtc);
- assertEquals(54000000L, ts.getTime()); // 1970-01-01 15:00:00 +0000
+ assertThat(ts.getTime(), is(54000000L));
ts = rs.getTimestamp(c, cGmt03);
- assertEquals(43200000L, ts.getTime()); // 1970-01-01 15:00:00 +0300
+ assertThat(ts.getTime(), is(43200000L));
ts = rs.getTimestamp(c, cGmt05);
- assertEquals(72000000L, ts.getTime()); // 1970-01-01 15:00:00 -0500
+ assertThat(ts.getTime(), is(72000000L));
ts = rs.getTimestamp(c, cGmt13);
- assertEquals(7200000L, ts.getTime()); // 1970-01-01 15:00:00 +1300
+ assertThat(ts.getTime(), is(7200000L));
s = rs.getString(c);
- assertEquals("15:00:00", s);
+ assertThat(s, is("15:00:00"));
++c;
if (false) {
// timetz: 15:00:00+03
ts = rs.getTimestamp(c);
- assertEquals(43200000L, ts.getTime()); // 1970-01-01 15:00:00 +0300 ->
+ assertThat(ts.getTime(), is(43200000L));
// 1970-01-01 13:00:00 +0100
ts = rs.getTimestamp(c, cUtc);
- assertEquals(43200000L, ts.getTime()); // 1970-01-01 15:00:00 +0300 ->
+ assertThat(ts.getTime(), is(43200000L));
// 1970-01-01 12:00:00 +0000
ts = rs.getTimestamp(c, cGmt03);
- assertEquals(43200000L, ts.getTime()); // 1970-01-01 15:00:00 +0300 ->
+ assertThat(ts.getTime(), is(43200000L));
// 1970-01-01 15:00:00 +0300
ts = rs.getTimestamp(c, cGmt05);
- assertEquals(43200000L, ts.getTime()); // 1970-01-01 15:00:00 +0300 ->
+ assertThat(ts.getTime(), is(43200000L));
// 1970-01-01 07:00:00 -0500
ts = rs.getTimestamp(c, cGmt13);
- assertEquals(43200000L, ts.getTime()); // 1970-01-01 15:00:00 +0300 ->
+ assertThat(ts.getTime(), is(43200000L));
// 1970-01-02 01:00:00 +1300
++c;
}
// date: 2005-01-01
ts = rs.getTimestamp(c);
- assertEquals(1104534000000L, ts.getTime()); // 2005-01-01 00:00:00 +0100
+ assertThat(ts.getTime(), is(1104534000000L));
ts = rs.getTimestamp(c, cUtc);
- assertEquals(1104537600000L, ts.getTime()); // 2005-01-01 00:00:00 +0000
+ assertThat(ts.getTime(), is(1104537600000L));
ts = rs.getTimestamp(c, cGmt03);
- assertEquals(1104526800000L, ts.getTime()); // 2005-01-01 00:00:00 +0300
+ assertThat(ts.getTime(), is(1104526800000L));
ts = rs.getTimestamp(c, cGmt05);
- assertEquals(1104555600000L, ts.getTime()); // 2005-01-01 00:00:00 -0500
+ assertThat(ts.getTime(), is(1104555600000L));
ts = rs.getTimestamp(c, cGmt13);
- assertEquals(1104490800000L, ts.getTime()); // 2005-01-01 00:00:00 +1300
+ assertThat(ts.getTime(), is(1104490800000L));
s = rs.getString(c);
- assertEquals("2005-01-01", s); // 2005-01-01 00:00:00 +0100
+ assertThat(s, is("2005-01-01"));
++c;
assertTrue(!rs.next());
@@ -6816,9 +6892,7 @@ public class JdbcTest {
stmt.executeQuery("select min(\"date\") mindate\n"
+ "from \"foodmart\".\"currency\"");
assertTrue(rs.next());
- assertEquals(
- Date.valueOf("1997-01-01"),
- rs.getDate(1));
+ assertThat(rs.getDate(1), is(Date.valueOf("1997-01-01")));
assertFalse(rs.next());
} catch (SQLException e) {
throw TestUtil.rethrow(e);
@@ -6845,9 +6919,8 @@ public class JdbcTest {
+ "from \"foodmart\".\"employee\"\n"
+ "where \"employee_id\" = 1");
assertTrue(rs.next());
- assertEquals(
- Timestamp.valueOf("1994-12-01 00:00:00"),
- rs.getTimestamp(1));
+ assertThat(rs.getTimestamp(1),
+ is(Timestamp.valueOf("1994-12-01 00:00:00")));
assertFalse(rs.next());
} catch (SQLException e) {
throw TestUtil.rethrow(e);
@@ -7286,7 +7359,7 @@ public class JdbcTest {
final int[] callCount = {0};
try (Hook.Closeable ignored =
Hook.PARSE_TREE.<Object[]>addThread(args -> {
- assertThat(args.length, is(2));
+ assertThat(args, arrayWithSize(2));
assertThat(args[0], instanceOf(String.class));
assertThat(args[0],
is("select \"deptno\", \"commission\", sum(\"salary\") s\n"
@@ -8431,10 +8504,10 @@ public class JdbcTest {
+ "FROM invoice\n"
+ "WHERE invoice.inv_amt < 10 AND invoice.inv_amt > 0";
ResultSet rs = calciteConnection.prepareStatement(statement).executeQuery();
- assert rs.next();
- assertEquals(rs.getInt(1), 10);
- assertEquals(rs.getInt(2), 3);
- assert !rs.next();
+ assertThat(rs.next(), is(true));
+ assertThat(rs.getInt(1), is(10));
+ assertThat(rs.getInt(2), is(3));
+ assertThat(rs.next(), is(false));
rs.close();
calciteConnection.close();
}
@@ -8450,8 +8523,8 @@ public class JdbcTest {
.returns(resultSet -> {
try {
assertTrue(resultSet.next());
- assertEquals("1500-04-30", resultSet.getString(1));
- assertEquals(Date.valueOf("1500-04-30"), resultSet.getDate(1));
+ assertThat(resultSet.getString(1), is("1500-04-30"));
+ assertThat(resultSet.getDate(1), is(Date.valueOf("1500-04-30")));
assertFalse(resultSet.next());
} catch (SQLException e) {
throw new RuntimeException(e);
@@ -8470,8 +8543,9 @@ public class JdbcTest {
.returns(resultSet -> {
try {
assertTrue(resultSet.next());
- assertEquals("1500-04-30 12:00:00", resultSet.getString(1));
- assertEquals(Timestamp.valueOf("1500-04-30 12:00:00"), resultSet.getTimestamp(1));
+ assertThat(resultSet.getString(1), is("1500-04-30 12:00:00"));
+ assertThat(resultSet.getTimestamp(1),
+ is(Timestamp.valueOf("1500-04-30 12:00:00")));
assertFalse(resultSet.next());
} catch (SQLException e) {
throw new RuntimeException(e);
@@ -8492,8 +8566,8 @@ public class JdbcTest {
.returns(resultSet -> {
try {
assertTrue(resultSet.next());
- assertEquals("1500-04-30", resultSet.getString(1));
- assertEquals(date, resultSet.getDate(1));
+ assertThat(resultSet.getString(1), is("1500-04-30"));
+ assertThat(resultSet.getDate(1), is(date));
assertFalse(resultSet.next());
} catch (SQLException e) {
throw new RuntimeException(e);
@@ -8514,8 +8588,8 @@ public class JdbcTest {
.returns(resultSet -> {
try {
assertTrue(resultSet.next());
- assertEquals("1500-04-30 12:00:00", resultSet.getString(1));
- assertEquals(timestamp, resultSet.getTimestamp(1));
+ assertThat(resultSet.getString(1), is("1500-04-30 12:00:00"));
+ assertThat(resultSet.getTimestamp(1), is(timestamp));
assertFalse(resultSet.next());
} catch (SQLException e) {
throw new RuntimeException(e);
diff --git a/core/src/test/java/org/apache/calcite/test/LargeGeneratedJoinTest.java b/core/src/test/java/org/apache/calcite/test/LargeGeneratedJoinTest.java
index 8a4d19f4e5..ba560064c2 100644
--- a/core/src/test/java/org/apache/calcite/test/LargeGeneratedJoinTest.java
+++ b/core/src/test/java/org/apache/calcite/test/LargeGeneratedJoinTest.java
@@ -47,8 +47,9 @@ import java.util.function.Function;
import static org.apache.calcite.config.CalciteSystemProperty.JOIN_SELECTOR_COMPACT_CODE_THRESHOLD;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.nullValue;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
@@ -159,25 +160,25 @@ public class LargeGeneratedJoinTest {
query.returns(rs -> {
try {
assertTrue(rs.next());
- assertEquals(1 + getT0Size() + getT1Size(), rs.getMetaData().getColumnCount());
+ assertThat(rs.getMetaData().getColumnCount(),
+ is(1 + getT0Size() + getT1Size()));
long row = 0;
do {
++row;
for (int i = 1; i <= rs.getMetaData().getColumnCount(); ++i) {
// Rows have the format: v0v1, v0, v1, v2, ..., v99, v0, v1, v2, ..., v99, v100
+ final String reason = "Error at row: " + row + ", column: " + i;
if (i == 1) {
- assertEquals("v0v1", rs.getString(i),
- "Error at row: " + row + ", column: " + i);
+ assertThat(reason, rs.getString(i), is("v0v1"));
} else if (i <= getT0Size() + 1) {
- assertEquals("v" + (i - 2), rs.getString(i),
- "Error at row: " + row + ", column: " + i);
+ assertThat(reason, rs.getString(i), is("v" + (i - 2)));
} else {
- assertEquals("v" + ((i - 2) - getT0Size()), rs.getString(i),
- "Error at row: " + row + ", column: " + i);
+ assertThat(reason, rs.getString(i),
+ is("v" + ((i - 2) - getT0Size())));
}
}
} while (rs.next());
- assertEquals(4, row);
+ assertThat(row, is(4L));
} catch (SQLException e) {
throw new RuntimeException(e);
}
@@ -201,25 +202,24 @@ public class LargeGeneratedJoinTest {
query.returns(rs -> {
try {
assertTrue(rs.next());
- assertEquals(1 + getT0Size() + getT1Size(), rs.getMetaData().getColumnCount());
+ assertThat(rs.getMetaData().getColumnCount(),
+ is(1 + getT0Size() + getT1Size()));
long row = 0;
do {
++row;
for (int i = 1; i <= rs.getMetaData().getColumnCount(); ++i) {
// Rows have the format: v0v1, v0, v1, v2, ..., v99, null, ..., null
+ final String reason = "Error at row: " + row + ", column: " + i;
if (i == 1) {
- assertEquals("v0v1", rs.getString(i),
- "Error at row: " + row + ", column: " + i);
+ assertThat(reason, rs.getString(i), is("v0v1"));
} else if (i <= getT0Size() + 1) {
- assertEquals("v" + (i - 2), rs.getString(i),
- "Error at row: " + row + ", column: " + i);
+ assertThat(reason, rs.getString(i), is("v" + (i - 2)));
} else {
- assertNull(rs.getString(i),
- "Error at row: " + row + ", column: " + i);
+ assertThat(reason, rs.getString(i), nullValue());
}
}
} while (rs.next());
- assertEquals(2, row);
+ assertThat(row, is(2L));
} catch (SQLException e) {
throw new RuntimeException(e);
}
@@ -243,25 +243,25 @@ public class LargeGeneratedJoinTest {
query.returns(rs -> {
try {
assertTrue(rs.next());
- assertEquals(1 + getT0Size() + getT1Size(), rs.getMetaData().getColumnCount());
+ assertThat(rs.getMetaData().getColumnCount(),
+ is(1 + getT0Size() + getT1Size()));
long row = 0;
do {
++row;
for (int i = 1; i <= rs.getMetaData().getColumnCount(); ++i) {
// Rows have the format: v0v1, null, ..., null, v0, v1, v2, ..., v100
+ final String reason = "Error at row: " + row + ", column: " + i;
if (i == 1) {
- assertEquals("v0v1", rs.getString(i),
- "Error at row: " + row + ", column: " + i);
+ assertThat(reason, rs.getString(i), is("v0v1"));
} else if (i <= getT0Size() + 1) {
- assertNull(rs.getString(i),
- "Error at row: " + row + ", column: " + i);
+ assertThat(reason, rs.getString(i), nullValue());
} else {
- assertEquals("v" + (i - 2 - getT0Size()), rs.getString(i),
- "Error at row: " + row + ", column: " + i);
+ assertThat(reason, rs.getString(i),
+ is("v" + (i - 2 - getT0Size())));
}
}
} while (rs.next());
- assertEquals(2, row);
+ assertThat(row, is(2L));
} catch (SQLException e) {
throw new RuntimeException(e);
}
@@ -285,45 +285,40 @@ public class LargeGeneratedJoinTest {
query.returns(rs -> {
try {
assertTrue(rs.next());
- assertEquals(1 + 1 + getT0Size() + getT1Size(), rs.getMetaData().getColumnCount());
+ assertThat(rs.getMetaData().getColumnCount(),
+ is(1 + 1 + getT0Size() + getT1Size()));
long row = 0;
do {
++row;
for (int i = 1; i <= rs.getMetaData().getColumnCount(); ++i) {
+ final String reason = "Error at row: " + row + ", column: " + i;
if (row <= 2) {
// First 2 rows have the format: v0v1, null, v0, v1, v2, ..., v99, null, ..., null
if (i == 1) {
- assertEquals("v0v1", rs.getString(i),
- "Error at row: " + row + ", column: " + i);
+ assertThat(reason, rs.getString(i), is("v0v1"));
} else if (i == 2) {
- assertNull(rs.getString(i),
- "Error at row: " + row + ", column: " + i);
+ assertThat(reason, rs.getString(i), nullValue());
} else if (i <= getT0Size() + 2) {
- assertEquals("v" + (i - 3), rs.getString(i),
- "Error at row: " + row + ", column: " + i);
+ assertThat(reason, rs.getString(i), is("v" + (i - 3)));
} else {
- assertNull(rs.getString(i),
- "Error at row: " + row + ", column: " + i);
+ assertThat(reason, rs.getString(i), nullValue());
}
} else {
// Last 2 rows have the format: null, v0v1, null, ..., null, v0, v1, v2, ..., v100
if (i == 1) {
- assertNull(rs.getString(i),
- "Error at row: " + row + ", column: " + i);
+ assertThat(reason, rs.getString(i), nullValue());
} else if (i == 2) {
- assertEquals("v0v1", rs.getString(i),
- "Error at row: " + row + ", column: " + i);
+ assertThat(reason, rs.getString(i), is("v0v1"));
} else if (i <= getT0Size() + 2) {
- assertNull(rs.getString(i),
- "Error at row: " + row + ", column: " + i);
+ assertThat(reason, rs.getString(i), nullValue());
} else {
- assertEquals("v" + (i - 3 - getT0Size()), rs.getString(i),
- "Error at row: " + row + ", column: " + i);
+ assertThat(reason, rs.getString(i),
+ is("v" + (i - 3 - getT0Size())));
}
}
}
} while (rs.next());
- assertEquals(4, row);
+ assertThat(row, is(4L));
} catch (SQLException e) {
throw new RuntimeException(e);
}
diff --git a/core/src/test/java/org/apache/calcite/test/LatticeTest.java b/core/src/test/java/org/apache/calcite/test/LatticeTest.java
index 05da0246fb..bb50650d62 100644
--- a/core/src/test/java/org/apache/calcite/test/LatticeTest.java
+++ b/core/src/test/java/org/apache/calcite/test/LatticeTest.java
@@ -49,13 +49,13 @@ import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Consumer;
import static org.apache.calcite.test.Matchers.containsStringLinux;
-import static org.apache.calcite.test.Matchers.within;
import static org.hamcrest.CoreMatchers.anyOf;
import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.closeTo;
import static org.hamcrest.Matchers.hasSize;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assumptions.assumeTrue;
@@ -984,12 +984,12 @@ class LatticeTest {
/** Unit test for {@link Lattice#getRowCount(double, List)}. */
@Test void testColumnCount() {
- assertThat(Lattice.getRowCount(10, 2, 3), within(5.03D, 0.01D));
- assertThat(Lattice.getRowCount(10, 9, 8), within(9.4D, 0.01D));
- assertThat(Lattice.getRowCount(100, 9, 8), within(54.2D, 0.1D));
- assertThat(Lattice.getRowCount(1000, 9, 8), within(72D, 0.01D));
+ assertThat(Lattice.getRowCount(10, 2, 3), closeTo(5.03D, 0.01D));
+ assertThat(Lattice.getRowCount(10, 9, 8), closeTo(9.4D, 0.01D));
+ assertThat(Lattice.getRowCount(100, 9, 8), closeTo(54.2D, 0.1D));
+ assertThat(Lattice.getRowCount(1000, 9, 8), closeTo(72D, 0.01D));
assertThat(Lattice.getRowCount(1000, 1, 1), is(1D));
- assertThat(Lattice.getRowCount(1, 3, 5), within(1D, 0.01D));
- assertThat(Lattice.getRowCount(1, 3, 5, 13, 4831), within(1D, 0.01D));
+ assertThat(Lattice.getRowCount(1, 3, 5), closeTo(1D, 0.01D));
+ assertThat(Lattice.getRowCount(1, 3, 5, 13, 4831), closeTo(1D, 0.01D));
}
}
diff --git a/core/src/test/java/org/apache/calcite/test/MaterializedViewSubstitutionVisitorTest.java b/core/src/test/java/org/apache/calcite/test/MaterializedViewSubstitutionVisitorTest.java
index c907c1d405..8e1419e916 100644
--- a/core/src/test/java/org/apache/calcite/test/MaterializedViewSubstitutionVisitorTest.java
+++ b/core/src/test/java/org/apache/calcite/test/MaterializedViewSubstitutionVisitorTest.java
@@ -48,7 +48,6 @@ import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.hasToString;
-import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -2093,7 +2092,7 @@ public class MaterializedViewSubstitutionVisitorTest {
void checkSatisfiable(RexNode e, String s) {
assertTrue(SubstitutionVisitor.mayBeSatisfiable(e));
final RexNode simple = simplify.simplifyUnknownAsFalse(e);
- assertEquals(s, simple.toString());
+ assertThat(simple, hasToString(s));
}
}
diff --git a/core/src/test/java/org/apache/calcite/test/ModelTest.java b/core/src/test/java/org/apache/calcite/test/ModelTest.java
index 795a6b36f1..d63d4bc43b 100644
--- a/core/src/test/java/org/apache/calcite/test/ModelTest.java
+++ b/core/src/test/java/org/apache/calcite/test/ModelTest.java
@@ -38,12 +38,12 @@ import java.util.List;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.anEmptyMap;
import static org.hamcrest.Matchers.hasSize;
-import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
@@ -104,22 +104,22 @@ class ModelTest {
+ " ]\n"
+ "}";
JsonRoot root = mapper.readValue(json, JsonRoot.class);
- assertEquals("1.0", root.version);
- assertEquals(1, root.schemas.size());
+ assertThat(root.version, is("1.0"));
+ assertThat(root.schemas, hasSize(1));
final JsonMapSchema schema = (JsonMapSchema) root.schemas.get(0);
- assertEquals("FoodMart", schema.name);
- assertEquals(1, schema.types.size());
+ assertThat(schema.name, is("FoodMart"));
+ assertThat(schema.types, hasSize(1));
final List<JsonTypeAttribute> attributes = schema.types.get(0).attributes;
- assertEquals("f1", attributes.get(0).name);
- assertEquals("BIGINT", attributes.get(0).type);
- assertEquals(2, schema.tables.size());
+ assertThat(attributes.get(0).name, is("f1"));
+ assertThat(attributes.get(0).type, is("BIGINT"));
+ assertThat(schema.tables, hasSize(2));
final JsonTable table0 = schema.tables.get(0);
- assertEquals("time_by_day", table0.name);
+ assertThat(table0.name, is("time_by_day"));
final JsonTable table1 = schema.tables.get(1);
- assertEquals("sales_fact_1997", table1.name);
- assertEquals(1, table0.columns.size());
+ assertThat(table1.name, is("sales_fact_1997"));
+ assertThat(table0.columns, hasSize(1));
final JsonColumn column = table0.columns.get(0);
- assertEquals("time_id", column.name);
+ assertThat(column.name, is("time_id"));
}
/** Reads a simple schema containing JdbcSchema, a sub-type of Schema. */
@@ -140,10 +140,10 @@ class ModelTest {
+ " ]\n"
+ "}";
JsonRoot root = mapper.readValue(json, JsonRoot.class);
- assertEquals("1.0", root.version);
- assertEquals(1, root.schemas.size());
+ assertThat(root.version, is("1.0"));
+ assertThat(root.schemas, hasSize(1));
final JsonJdbcSchema schema = (JsonJdbcSchema) root.schemas.get(0);
- assertEquals("FoodMart", schema.name);
+ assertThat(schema.name, is("FoodMart"));
}
/** Reads a custom schema. */
@@ -171,19 +171,19 @@ class ModelTest {
+ " ]\n"
+ "}",
JsonRoot.class);
- assertEquals("1.0", root.version);
- assertEquals(2, root.schemas.size());
+ assertThat(root.version, is("1.0"));
+ assertThat(root.schemas, hasSize(2));
final JsonCustomSchema schema = (JsonCustomSchema) root.schemas.get(0);
- assertEquals("My Custom Schema", schema.name);
- assertEquals("com.acme.MySchemaFactory", schema.factory);
+ assertThat(schema.name, is("My Custom Schema"));
+ assertThat(schema.factory, is("com.acme.MySchemaFactory"));
assertThat(schema.operand, notNullValue());
- assertEquals("foo", schema.operand.get("a"));
+ assertThat(schema.operand.get("a"), is("foo"));
assertNull(schema.operand.get("c"));
assertThat(schema.operand.get("b"), instanceOf(List.class));
final List<Object> list = (List<Object>) schema.operand.get("b");
- assertEquals(2, list.size());
- assertEquals(1, list.get(0));
- assertEquals(3.5, list.get(1));
+ assertThat(list, hasSize(2));
+ assertThat(list.get(0), is(1));
+ assertThat(list.get(1), is(3.5));
assertThat(schema.tables, hasSize(3));
final JsonCustomTable table0 = (JsonCustomTable) schema.tables.get(0);
@@ -309,25 +309,25 @@ class ModelTest {
+ " ]\n"
+ "}",
JsonRoot.class);
- assertEquals("1.0", root.version);
- assertEquals(1, root.schemas.size());
+ assertThat(root.version, is("1.0"));
+ assertThat(root.schemas, hasSize(1));
final JsonMapSchema schema = (JsonMapSchema) root.schemas.get(0);
- assertEquals("FoodMart", schema.name);
- assertEquals(2, schema.lattices.size());
+ assertThat(schema.name, is("FoodMart"));
+ assertThat(schema.lattices, hasSize(2));
final JsonLattice lattice0 = schema.lattices.get(0);
- assertEquals("SalesStar", lattice0.name);
- assertEquals("select * from sales_fact_1997", lattice0.getSql());
+ assertThat(lattice0.name, is("SalesStar"));
+ assertThat(lattice0.getSql(), is("select * from sales_fact_1997"));
final JsonLattice lattice1 = schema.lattices.get(1);
- assertEquals("SalesStar2", lattice1.name);
- assertEquals("select *\nfrom sales_fact_1997\n", lattice1.getSql());
- assertEquals(4, schema.tables.size());
+ assertThat(lattice1.name, is("SalesStar2"));
+ assertThat(lattice1.getSql(), is("select *\nfrom sales_fact_1997\n"));
+ assertThat(schema.tables, hasSize(4));
final JsonTable table1 = schema.tables.get(1);
assertTrue(!(table1 instanceof JsonView));
final JsonTable table2 = schema.tables.get(2);
- assertTrue(table2 instanceof JsonView);
+ assertThat(table2, instanceOf(JsonView.class));
assertThat(((JsonView) table2).getSql(), equalTo("values (1)"));
final JsonTable table3 = schema.tables.get(3);
- assertTrue(table3 instanceof JsonView);
+ assertThat(table3, instanceOf(JsonView.class));
assertThat(((JsonView) table3).getSql(), equalTo("values (1)\n(2)\n"));
}
@@ -350,9 +350,9 @@ class ModelTest {
+ " ]\n"
+ "}",
JsonRoot.class);
- assertEquals(1, root.schemas.size());
+ assertThat(root.schemas, hasSize(1));
final JsonMapSchema schema = (JsonMapSchema) root.schemas.get(0);
- assertEquals(1, schema.tables.size());
+ assertThat(schema.tables, hasSize(1));
final JsonView table1 = (JsonView) schema.tables.get(0);
try {
String s = table1.getSql();
diff --git a/core/src/test/java/org/apache/calcite/test/MutableRelTest.java b/core/src/test/java/org/apache/calcite/test/MutableRelTest.java
index 9614299b81..a627914bd1 100644
--- a/core/src/test/java/org/apache/calcite/test/MutableRelTest.java
+++ b/core/src/test/java/org/apache/calcite/test/MutableRelTest.java
@@ -41,9 +41,9 @@ import static org.apache.calcite.plan.RelOptUtil.equal;
import static org.apache.calcite.util.Litmus.IGNORE;
import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -214,7 +214,7 @@ class MutableRelTest {
+ "LogicalProject(I=[$0])\n"
+ " LogicalTableFunctionScan(invocation=[RAMP(3)], rowType=[RecordType(INTEGER I)])\n";
MatcherAssert.assertThat(actual, Matchers.isLinux(expected));
- assertEquals(mutableRel1, mutableRel2);
+ assertThat(mutableRel2, is(mutableRel1));
}
/** Verifies equivalence of {@link MutableScan}. */
@@ -293,7 +293,7 @@ class MutableRelTest {
final String msg3 =
"The converted new rel is different from the original rel.\n"
+ "Original rel: " + origRelStr + ";\nNew rel: " + newRelStr;
- assertEquals(origRelStr, newRelStr, msg3);
+ assertThat(msg3, newRelStr, is(origRelStr));
}
private static MutableRel createMutableRel(String sql) {
diff --git a/core/src/test/java/org/apache/calcite/test/ReflectiveSchemaTest.java b/core/src/test/java/org/apache/calcite/test/ReflectiveSchemaTest.java
index 0ed43d2783..d00ce08168 100644
--- a/core/src/test/java/org/apache/calcite/test/ReflectiveSchemaTest.java
+++ b/core/src/test/java/org/apache/calcite/test/ReflectiveSchemaTest.java
@@ -63,11 +63,14 @@ import java.util.BitSet;
import java.util.List;
import java.util.Properties;
+import static org.apache.calcite.test.Matchers.isListOf;
+
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.arrayWithSize;
+import static org.hamcrest.Matchers.hasSize;
import static org.hamcrest.Matchers.hasToString;
-import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
@@ -142,10 +145,10 @@ public class ReflectiveSchemaTest {
"toUpperCase")),
e))
.toList();
- assertEquals(1, list.size());
- assertEquals(2, list.get(0).length);
- assertEquals(150, list.get(0)[0]);
- assertEquals("SEBASTIAN", list.get(0)[1]);
+ assertThat(list, hasSize(1));
+ assertThat(list.get(0), arrayWithSize(2));
+ assertThat(list.get(0)[0], is(150));
+ assertThat(list.get(0)[1], is("SEBASTIAN"));
}
@Test void testQueryProviderSingleColumn() throws Exception {
@@ -170,7 +173,7 @@ public class ReflectiveSchemaTest {
Expressions.field(e, "empid"),
e))
.toList();
- assertEquals(Arrays.asList(100, 200, 150, 110), list);
+ assertThat(list, isListOf(100, 200, 150, 110));
}
/**
@@ -255,16 +258,16 @@ public class ReflectiveSchemaTest {
// "hr_emps" -> "hr"."emps", 4 rows
ResultSet resultSet =
statement.executeQuery("select * from \"s\".\"hr_emps\"");
- assertEquals(4, count(resultSet));
+ assertThat(count(resultSet), is(4));
// "s_emps" -> "s"."emps", 3 rows
resultSet =
statement.executeQuery("select * from \"s\".\"s_emps\"");
- assertEquals(3, count(resultSet));
+ assertThat(count(resultSet), is(3));
// "null_emps" -> "s"."emps", 3
resultSet = statement.executeQuery("select * from \"s\".\"null_emps\"");
- assertEquals(3, count(resultSet));
+ assertThat(count(resultSet), is(3));
statement.close();
}
@@ -944,7 +947,7 @@ public class ReflectiveSchemaTest {
assertNotNull(table);
Statistic statistic = table.getStatistic();
assertNotNull(statistic);
- assertEquals(4, statistic.getRowCount());
+ assertThat(statistic.getRowCount(), is(4D));
}
@Test void testCollectionFieldTableHasRowCount() {
@@ -953,6 +956,6 @@ public class ReflectiveSchemaTest {
assertNotNull(table);
Statistic statistic = table.getStatistic();
assertNotNull(statistic);
- assertEquals(2, statistic.getRowCount());
+ assertThat(statistic.getRowCount(), is(2D));
}
}
diff --git a/core/src/test/java/org/apache/calcite/test/RelBuilderTest.java b/core/src/test/java/org/apache/calcite/test/RelBuilderTest.java
index a425a2a61e..2f0293feb5 100644
--- a/core/src/test/java/org/apache/calcite/test/RelBuilderTest.java
+++ b/core/src/test/java/org/apache/calcite/test/RelBuilderTest.java
@@ -126,6 +126,7 @@ import static org.apache.calcite.test.Matchers.hasTree;
import static org.hamcrest.CoreMatchers.allOf;
import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.nullValue;
@@ -903,10 +904,10 @@ public class RelBuilderTest {
@Test void testProjectMapping() {
final RelBuilder builder = RelBuilder.create(config().build());
RelNode root =
- builder.scan("EMP")
- .project(builder.field(0), builder.field(0))
- .build();
- assertTrue(root instanceof Project);
+ builder.scan("EMP")
+ .project(builder.field(0), builder.field(0))
+ .build();
+ assertThat(root, instanceOf(Project.class));
Project project = (Project) root;
Mappings.TargetMapping mapping = project.getMapping();
assertThat(mapping, nullValue());
diff --git a/core/src/test/java/org/apache/calcite/test/RelMetadataTest.java b/core/src/test/java/org/apache/calcite/test/RelMetadataTest.java
index af135ce7a7..39e871961c 100644
--- a/core/src/test/java/org/apache/calcite/test/RelMetadataTest.java
+++ b/core/src/test/java/org/apache/calcite/test/RelMetadataTest.java
@@ -138,7 +138,6 @@ import static com.google.common.collect.ImmutableList.toImmutableList;
import static org.apache.calcite.test.Matchers.hasFieldNames;
import static org.apache.calcite.test.Matchers.isAlmost;
import static org.apache.calcite.test.Matchers.sortsAs;
-import static org.apache.calcite.test.Matchers.within;
import static org.hamcrest.CoreMatchers.anyOf;
import static org.hamcrest.CoreMatchers.endsWith;
@@ -150,9 +149,9 @@ import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.closeTo;
import static org.hamcrest.Matchers.hasSize;
import static org.hamcrest.Matchers.hasToString;
-import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
@@ -982,7 +981,7 @@ public class RelMetadataTest {
RelMetadataQuery.THREAD_PROVIDERS.set(JaninoRelMetadataProvider.of(wrappedProvider));
final RelMetadataQuery mq = rel.getCluster().getMetadataQuery();
final Double result = mq.getRowCount(rel);
- assertThat(result, within(14d, 0.1d));
+ assertThat(result, closeTo(14d, 0.1d));
}
}
@@ -1891,8 +1890,10 @@ public class RelMetadataTest {
// Top node is a filter. Its metadata uses getColType(RelNode, int).
assertThat(rel, instanceOf(LogicalFilter.class));
- assertThat(rel.getCluster().getMetadataQuery(), instanceOf(MyRelMetadataQuery.class));
- final MyRelMetadataQuery mq = (MyRelMetadataQuery) rel.getCluster().getMetadataQuery();
+ assertThat(rel.getCluster().getMetadataQuery(),
+ instanceOf(MyRelMetadataQuery.class));
+ final MyRelMetadataQuery mq =
+ (MyRelMetadataQuery) rel.getCluster().getMetadataQuery();
assertThat(colType(mq, rel, 0), equalTo("DEPTNO-rel"));
assertThat(colType(mq, rel, 1), equalTo("EXPR$1-rel"));
@@ -1921,8 +1922,10 @@ public class RelMetadataTest {
// Invalidate the metadata query triggers clearing of all the metadata.
rel.getCluster().invalidateMetadataQuery();
- assertThat(rel.getCluster().getMetadataQuery(), instanceOf(MyRelMetadataQuery.class));
- final MyRelMetadataQuery mq1 = (MyRelMetadataQuery) rel.getCluster().getMetadataQuery();
+ assertThat(rel.getCluster().getMetadataQuery(),
+ instanceOf(MyRelMetadataQuery.class));
+ final MyRelMetadataQuery mq1 =
+ (MyRelMetadataQuery) rel.getCluster().getMetadataQuery();
assertThat(colType(mq1, input, 0), equalTo("DEPTNO-agg"));
if (metadataConfig.isCaching()) {
assertThat(buf, hasSize(5));
@@ -1966,7 +1969,7 @@ public class RelMetadataTest {
final RelMetadataQuery mq = result.getCluster().getMetadataQuery();
final ImmutableList<RelCollation> collations = mq.collations(result);
assertThat(collations, notNullValue());
- assertEquals("[[0]]", collations.toString());
+ assertThat(collations, hasToString("[[0]]"));
}
/**
@@ -2006,7 +2009,7 @@ public class RelMetadataTest {
assertThat(relNode, instanceOf(Project.class));
final ImmutableList<RelCollation> collations = mq.collations(relNode);
assertThat(collations, notNullValue());
- assertEquals(expectedCollation, collations.toString());
+ assertThat(collations, hasToString(expectedCollation));
}
/** Unit test for
@@ -3195,7 +3198,7 @@ public class RelMetadataTest {
assertThat(call.getOperands(), hasSize(2));
final RexTableInputRef inputRef1 =
(RexTableInputRef) call.getOperands().get(0);
- assertTrue(inputRef1.getQualifiedName().equals(EMP_QNAME));
+ assertThat(inputRef1.getQualifiedName(), is(EMP_QNAME));
assertThat(inputRef1.getIndex(), is(0));
final RexLiteral constant = (RexLiteral) call.getOperands().get(1);
assertThat(constant, hasToString("5"));
@@ -3732,7 +3735,7 @@ public class RelMetadataTest {
Double popSize =
populationSize.getPopulationSize((Values) rel, rel.getCluster().getMetadataQuery(),
bitSetOf(0, 1, 2));
- assertEquals(2.0, popSize);
+ assertThat(popSize, is(2.0));
// If we use a custom RelMetadataQuery and override the row count, the population size
// should be half the reported row count. In this case we will have the RelMetadataQuery say
@@ -3744,7 +3747,7 @@ public class RelMetadataTest {
};
popSize = populationSize.getPopulationSize((Values) rel, customQuery, bitSetOf(0, 1, 2));
- assertEquals(6.0, popSize);
+ assertThat(popSize, is(6.0));
}
private static final SqlOperator NONDETERMINISTIC_OP =
diff --git a/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java b/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java
index 6720625e9a..380b543409 100644
--- a/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java
+++ b/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java
@@ -151,9 +151,10 @@ import java.util.function.Predicate;
import static org.apache.calcite.test.SqlToRelTestBase.NL;
+import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.sameInstance;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.Matchers.hasSize;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
@@ -493,11 +494,11 @@ class RelOptRulesTest extends RelOptTestBase {
filter.getTraitSet().getTrait(RelCollationTraitDef.INSTANCE);
assertNotNull(collation);
List<RelFieldCollation> fieldCollations = collation.getFieldCollations();
- assertEquals(1, fieldCollations.size());
+ assertThat(fieldCollations, hasSize(1));
RelFieldCollation fieldCollation = fieldCollations.get(0);
- assertEquals(3, fieldCollation.getFieldIndex());
- assertEquals(RelFieldCollation.Direction.DESCENDING,
- fieldCollation.getDirection());
+ assertThat(fieldCollation.getFieldIndex(), is(3));
+ assertThat(fieldCollation.getDirection(),
+ is(RelFieldCollation.Direction.DESCENDING));
}
}
@@ -8678,7 +8679,7 @@ class RelOptRulesTest extends RelOptTestBase {
final RelCollation collationAfter =
relAfter.getTraitSet().getTrait(RelCollationTraitDef.INSTANCE);
- assertEquals(collationBefore, collationAfter);
+ assertThat(collationAfter, is(collationBefore));
}
@Test void testPushFilterWithIsNotDistinctFromPastJoin() {
diff --git a/core/src/test/java/org/apache/calcite/test/ScannableTableTest.java b/core/src/test/java/org/apache/calcite/test/ScannableTableTest.java
index ee0e54919d..bf1af78bd9 100644
--- a/core/src/test/java/org/apache/calcite/test/ScannableTableTest.java
+++ b/core/src/test/java/org/apache/calcite/test/ScannableTableTest.java
@@ -64,6 +64,7 @@ import java.util.concurrent.atomic.AtomicInteger;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.arrayWithSize;
import static org.hamcrest.Matchers.hasToString;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -78,7 +79,7 @@ public class ScannableTableTest {
try (Enumerator<Object[]> cursor = tens()) {
assertTrue(cursor.moveNext());
assertThat(cursor.current()[0], equalTo(0));
- assertThat(cursor.current().length, equalTo(1));
+ assertThat(cursor.current(), arrayWithSize(1));
assertTrue(cursor.moveNext());
assertThat(cursor.current()[0], equalTo(10));
assertTrue(cursor.moveNext());
diff --git a/core/src/test/java/org/apache/calcite/test/SqlFunctionsTest.java b/core/src/test/java/org/apache/calcite/test/SqlFunctionsTest.java
index 7e37cd1557..93da75dec5 100644
--- a/core/src/test/java/org/apache/calcite/test/SqlFunctionsTest.java
+++ b/core/src/test/java/org/apache/calcite/test/SqlFunctionsTest.java
@@ -23,6 +23,7 @@ import org.apache.calcite.runtime.Utilities;
import com.google.common.collect.ImmutableList;
+import org.hamcrest.Matcher;
import org.junit.jupiter.api.Test;
import java.math.BigDecimal;
@@ -73,12 +74,13 @@ import static org.apache.calcite.runtime.SqlFunctions.toLong;
import static org.apache.calcite.runtime.SqlFunctions.toLongOptional;
import static org.apache.calcite.runtime.SqlFunctions.trim;
import static org.apache.calcite.runtime.SqlFunctions.upper;
-import static org.apache.calcite.test.Matchers.within;
+import static org.apache.calcite.test.Matchers.isListOf;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.closeTo;
import static org.hamcrest.Matchers.hasToString;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.fail;
@@ -870,129 +872,129 @@ class SqlFunctionsTest {
}
@Test void testSTruncateDouble() {
- assertThat(SqlFunctions.struncate(12.345d, 3), within(12.345d, 0.001));
- assertThat(SqlFunctions.struncate(12.345d, 2), within(12.340d, 0.001));
- assertThat(SqlFunctions.struncate(12.345d, 1), within(12.300d, 0.001));
- assertThat(SqlFunctions.struncate(12.999d, 0), within(12.000d, 0.001));
-
- assertThat(SqlFunctions.struncate(-12.345d, 3), within(-12.345d, 0.001));
- assertThat(SqlFunctions.struncate(-12.345d, 2), within(-12.340d, 0.001));
- assertThat(SqlFunctions.struncate(-12.345d, 1), within(-12.300d, 0.001));
- assertThat(SqlFunctions.struncate(-12.999d, 0), within(-12.000d, 0.001));
-
- assertThat(SqlFunctions.struncate(12345d, -3), within(12000d, 0.001));
- assertThat(SqlFunctions.struncate(12000d, -3), within(12000d, 0.001));
- assertThat(SqlFunctions.struncate(12001d, -3), within(12000d, 0.001));
- assertThat(SqlFunctions.struncate(12000d, -4), within(10000d, 0.001));
- assertThat(SqlFunctions.struncate(12000d, -5), within(0d, 0.001));
- assertThat(SqlFunctions.struncate(11999d, -3), within(11000d, 0.001));
-
- assertThat(SqlFunctions.struncate(-12345d, -3), within(-12000d, 0.001));
- assertThat(SqlFunctions.struncate(-12000d, -3), within(-12000d, 0.001));
- assertThat(SqlFunctions.struncate(-11999d, -3), within(-11000d, 0.001));
- assertThat(SqlFunctions.struncate(-12000d, -4), within(-10000d, 0.001));
- assertThat(SqlFunctions.struncate(-12000d, -5), within(0d, 0.001));
+ assertThat(SqlFunctions.struncate(12.345d, 3), closeTo(12.345d, 0.001));
+ assertThat(SqlFunctions.struncate(12.345d, 2), closeTo(12.340d, 0.001));
+ assertThat(SqlFunctions.struncate(12.345d, 1), closeTo(12.300d, 0.001));
+ assertThat(SqlFunctions.struncate(12.999d, 0), closeTo(12.000d, 0.001));
+
+ assertThat(SqlFunctions.struncate(-12.345d, 3), closeTo(-12.345d, 0.001));
+ assertThat(SqlFunctions.struncate(-12.345d, 2), closeTo(-12.340d, 0.001));
+ assertThat(SqlFunctions.struncate(-12.345d, 1), closeTo(-12.300d, 0.001));
+ assertThat(SqlFunctions.struncate(-12.999d, 0), closeTo(-12.000d, 0.001));
+
+ assertThat(SqlFunctions.struncate(12345d, -3), closeTo(12000d, 0.001));
+ assertThat(SqlFunctions.struncate(12000d, -3), closeTo(12000d, 0.001));
+ assertThat(SqlFunctions.struncate(12001d, -3), closeTo(12000d, 0.001));
+ assertThat(SqlFunctions.struncate(12000d, -4), closeTo(10000d, 0.001));
+ assertThat(SqlFunctions.struncate(12000d, -5), closeTo(0d, 0.001));
+ assertThat(SqlFunctions.struncate(11999d, -3), closeTo(11000d, 0.001));
+
+ assertThat(SqlFunctions.struncate(-12345d, -3), closeTo(-12000d, 0.001));
+ assertThat(SqlFunctions.struncate(-12000d, -3), closeTo(-12000d, 0.001));
+ assertThat(SqlFunctions.struncate(-11999d, -3), closeTo(-11000d, 0.001));
+ assertThat(SqlFunctions.struncate(-12000d, -4), closeTo(-10000d, 0.001));
+ assertThat(SqlFunctions.struncate(-12000d, -5), closeTo(0d, 0.001));
}
@Test void testSTruncateLong() {
- assertThat(SqlFunctions.struncate(12345L, -3), within(12000d, 0.001));
- assertThat(SqlFunctions.struncate(12000L, -3), within(12000d, 0.001));
- assertThat(SqlFunctions.struncate(12001L, -3), within(12000d, 0.001));
- assertThat(SqlFunctions.struncate(12000L, -4), within(10000d, 0.001));
- assertThat(SqlFunctions.struncate(12000L, -5), within(0d, 0.001));
- assertThat(SqlFunctions.struncate(11999L, -3), within(11000d, 0.001));
+ assertThat(SqlFunctions.struncate(12345L, -3), is(12000L));
+ assertThat(SqlFunctions.struncate(12000L, -3), is(12000L));
+ assertThat(SqlFunctions.struncate(12001L, -3), is(12000L));
+ assertThat(SqlFunctions.struncate(12000L, -4), is(10000L));
+ assertThat(SqlFunctions.struncate(12000L, -5), is(0L));
+ assertThat(SqlFunctions.struncate(11999L, -3), is(11000L));
- assertThat(SqlFunctions.struncate(-12345L, -3), within(-12000d, 0.001));
- assertThat(SqlFunctions.struncate(-12000L, -3), within(-12000d, 0.001));
- assertThat(SqlFunctions.struncate(-11999L, -3), within(-11000d, 0.001));
- assertThat(SqlFunctions.struncate(-12000L, -4), within(-10000d, 0.001));
- assertThat(SqlFunctions.struncate(-12000L, -5), within(0d, 0.001));
+ assertThat(SqlFunctions.struncate(-12345L, -3), is(-12000L));
+ assertThat(SqlFunctions.struncate(-12000L, -3), is(-12000L));
+ assertThat(SqlFunctions.struncate(-11999L, -3), is(-11000L));
+ assertThat(SqlFunctions.struncate(-12000L, -4), is(-10000L));
+ assertThat(SqlFunctions.struncate(-12000L, -5), is(0L));
}
@Test void testSTruncateInt() {
- assertThat(SqlFunctions.struncate(12345, -3), within(12000d, 0.001));
- assertThat(SqlFunctions.struncate(12000, -3), within(12000d, 0.001));
- assertThat(SqlFunctions.struncate(12001, -3), within(12000d, 0.001));
- assertThat(SqlFunctions.struncate(12000, -4), within(10000d, 0.001));
- assertThat(SqlFunctions.struncate(12000, -5), within(0d, 0.001));
- assertThat(SqlFunctions.struncate(11999, -3), within(11000d, 0.001));
+ assertThat(SqlFunctions.struncate(12345, -3), is(12000));
+ assertThat(SqlFunctions.struncate(12000, -3), is(12000));
+ assertThat(SqlFunctions.struncate(12001, -3), is(12000));
+ assertThat(SqlFunctions.struncate(12000, -4), is(10000));
+ assertThat(SqlFunctions.struncate(12000, -5), is(0));
+ assertThat(SqlFunctions.struncate(11999, -3), is(11000));
- assertThat(SqlFunctions.struncate(-12345, -3), within(-12000d, 0.001));
- assertThat(SqlFunctions.struncate(-12000, -3), within(-12000d, 0.001));
- assertThat(SqlFunctions.struncate(-11999, -3), within(-11000d, 0.001));
- assertThat(SqlFunctions.struncate(-12000, -4), within(-10000d, 0.001));
- assertThat(SqlFunctions.struncate(-12000, -5), within(0d, 0.001));
+ assertThat(SqlFunctions.struncate(-12345, -3), is(-12000));
+ assertThat(SqlFunctions.struncate(-12000, -3), is(-12000));
+ assertThat(SqlFunctions.struncate(-11999, -3), is(-11000));
+ assertThat(SqlFunctions.struncate(-12000, -4), is(-10000));
+ assertThat(SqlFunctions.struncate(-12000, -5), is(0));
}
@Test void testSRoundDouble() {
- assertThat(SqlFunctions.sround(12.345d, 3), within(12.345d, 0.001));
- assertThat(SqlFunctions.sround(12.345d, 2), within(12.350d, 0.001));
- assertThat(SqlFunctions.sround(12.345d, 1), within(12.300d, 0.001));
- assertThat(SqlFunctions.sround(12.999d, 2), within(13.000d, 0.001));
- assertThat(SqlFunctions.sround(12.999d, 1), within(13.000d, 0.001));
- assertThat(SqlFunctions.sround(12.999d, 0), within(13.000d, 0.001));
-
- assertThat(SqlFunctions.sround(-12.345d, 3), within(-12.345d, 0.001));
- assertThat(SqlFunctions.sround(-12.345d, 2), within(-12.350d, 0.001));
- assertThat(SqlFunctions.sround(-12.345d, 1), within(-12.300d, 0.001));
- assertThat(SqlFunctions.sround(-12.999d, 2), within(-13.000d, 0.001));
- assertThat(SqlFunctions.sround(-12.999d, 1), within(-13.000d, 0.001));
- assertThat(SqlFunctions.sround(-12.999d, 0), within(-13.000d, 0.001));
-
- assertThat(SqlFunctions.sround(12345d, -1), within(12350d, 0.001));
- assertThat(SqlFunctions.sround(12345d, -2), within(12300d, 0.001));
- assertThat(SqlFunctions.sround(12345d, -3), within(12000d, 0.001));
- assertThat(SqlFunctions.sround(12000d, -3), within(12000d, 0.001));
- assertThat(SqlFunctions.sround(12001d, -3), within(12000d, 0.001));
- assertThat(SqlFunctions.sround(12000d, -4), within(10000d, 0.001));
- assertThat(SqlFunctions.sround(12000d, -5), within(0d, 0.001));
- assertThat(SqlFunctions.sround(11999d, -3), within(12000d, 0.001));
-
- assertThat(SqlFunctions.sround(-12345d, -1), within(-12350d, 0.001));
- assertThat(SqlFunctions.sround(-12345d, -2), within(-12300d, 0.001));
- assertThat(SqlFunctions.sround(-12345d, -3), within(-12000d, 0.001));
- assertThat(SqlFunctions.sround(-12000d, -3), within(-12000d, 0.001));
- assertThat(SqlFunctions.sround(-11999d, -3), within(-12000d, 0.001));
- assertThat(SqlFunctions.sround(-12000d, -4), within(-10000d, 0.001));
- assertThat(SqlFunctions.sround(-12000d, -5), within(0d, 0.001));
+ assertThat(SqlFunctions.sround(12.345d, 3), closeTo(12.345d, 0.001));
+ assertThat(SqlFunctions.sround(12.345d, 2), closeTo(12.350d, 0.001));
+ assertThat(SqlFunctions.sround(12.345d, 1), closeTo(12.300d, 0.001));
+ assertThat(SqlFunctions.sround(12.999d, 2), closeTo(13.000d, 0.001));
+ assertThat(SqlFunctions.sround(12.999d, 1), closeTo(13.000d, 0.001));
+ assertThat(SqlFunctions.sround(12.999d, 0), closeTo(13.000d, 0.001));
+
+ assertThat(SqlFunctions.sround(-12.345d, 3), closeTo(-12.345d, 0.001));
+ assertThat(SqlFunctions.sround(-12.345d, 2), closeTo(-12.350d, 0.001));
+ assertThat(SqlFunctions.sround(-12.345d, 1), closeTo(-12.300d, 0.001));
+ assertThat(SqlFunctions.sround(-12.999d, 2), closeTo(-13.000d, 0.001));
+ assertThat(SqlFunctions.sround(-12.999d, 1), closeTo(-13.000d, 0.001));
+ assertThat(SqlFunctions.sround(-12.999d, 0), closeTo(-13.000d, 0.001));
+
+ assertThat(SqlFunctions.sround(12345d, -1), closeTo(12350d, 0.001));
+ assertThat(SqlFunctions.sround(12345d, -2), closeTo(12300d, 0.001));
+ assertThat(SqlFunctions.sround(12345d, -3), closeTo(12000d, 0.001));
+ assertThat(SqlFunctions.sround(12000d, -3), closeTo(12000d, 0.001));
+ assertThat(SqlFunctions.sround(12001d, -3), closeTo(12000d, 0.001));
+ assertThat(SqlFunctions.sround(12000d, -4), closeTo(10000d, 0.001));
+ assertThat(SqlFunctions.sround(12000d, -5), closeTo(0d, 0.001));
+ assertThat(SqlFunctions.sround(11999d, -3), closeTo(12000d, 0.001));
+
+ assertThat(SqlFunctions.sround(-12345d, -1), closeTo(-12350d, 0.001));
+ assertThat(SqlFunctions.sround(-12345d, -2), closeTo(-12300d, 0.001));
+ assertThat(SqlFunctions.sround(-12345d, -3), closeTo(-12000d, 0.001));
+ assertThat(SqlFunctions.sround(-12000d, -3), closeTo(-12000d, 0.001));
+ assertThat(SqlFunctions.sround(-11999d, -3), closeTo(-12000d, 0.001));
+ assertThat(SqlFunctions.sround(-12000d, -4), closeTo(-10000d, 0.001));
+ assertThat(SqlFunctions.sround(-12000d, -5), closeTo(0d, 0.001));
}
@Test void testSRoundLong() {
- assertThat(SqlFunctions.sround(12345L, -1), within(12350d, 0.001));
- assertThat(SqlFunctions.sround(12345L, -2), within(12300d, 0.001));
- assertThat(SqlFunctions.sround(12345L, -3), within(12000d, 0.001));
- assertThat(SqlFunctions.sround(12000L, -3), within(12000d, 0.001));
- assertThat(SqlFunctions.sround(12001L, -3), within(12000d, 0.001));
- assertThat(SqlFunctions.sround(12000L, -4), within(10000d, 0.001));
- assertThat(SqlFunctions.sround(12000L, -5), within(0d, 0.001));
- assertThat(SqlFunctions.sround(11999L, -3), within(12000d, 0.001));
-
- assertThat(SqlFunctions.sround(-12345L, -1), within(-12350d, 0.001));
- assertThat(SqlFunctions.sround(-12345L, -2), within(-12300d, 0.001));
- assertThat(SqlFunctions.sround(-12345L, -3), within(-12000d, 0.001));
- assertThat(SqlFunctions.sround(-12000L, -3), within(-12000d, 0.001));
- assertThat(SqlFunctions.sround(-11999L, -3), within(-12000d, 0.001));
- assertThat(SqlFunctions.sround(-12000L, -4), within(-10000d, 0.001));
- assertThat(SqlFunctions.sround(-12000L, -5), within(0d, 0.001));
+ assertThat(SqlFunctions.sround(12345L, -1), is(12350L));
+ assertThat(SqlFunctions.sround(12345L, -2), is(12300L));
+ assertThat(SqlFunctions.sround(12345L, -3), is(12000L));
+ assertThat(SqlFunctions.sround(12000L, -3), is(12000L));
+ assertThat(SqlFunctions.sround(12001L, -3), is(12000L));
+ assertThat(SqlFunctions.sround(12000L, -4), is(10000L));
+ assertThat(SqlFunctions.sround(12000L, -5), is(0L));
+ assertThat(SqlFunctions.sround(11999L, -3), is(12000L));
+
+ assertThat(SqlFunctions.sround(-12345L, -1), is(-12350L));
+ assertThat(SqlFunctions.sround(-12345L, -2), is(-12300L));
+ assertThat(SqlFunctions.sround(-12345L, -3), is(-12000L));
+ assertThat(SqlFunctions.sround(-12000L, -3), is(-12000L));
+ assertThat(SqlFunctions.sround(-11999L, -3), is(-12000L));
+ assertThat(SqlFunctions.sround(-12000L, -4), is(-10000L));
+ assertThat(SqlFunctions.sround(-12000L, -5), is(0L));
}
@Test void testSRoundInt() {
- assertThat(SqlFunctions.sround(12345, -1), within(12350d, 0.001));
- assertThat(SqlFunctions.sround(12345, -2), within(12300d, 0.001));
- assertThat(SqlFunctions.sround(12345, -3), within(12000d, 0.001));
- assertThat(SqlFunctions.sround(12000, -3), within(12000d, 0.001));
- assertThat(SqlFunctions.sround(12001, -3), within(12000d, 0.001));
- assertThat(SqlFunctions.sround(12000, -4), within(10000d, 0.001));
- assertThat(SqlFunctions.sround(12000, -5), within(0d, 0.001));
- assertThat(SqlFunctions.sround(11999, -3), within(12000d, 0.001));
-
- assertThat(SqlFunctions.sround(-12345, -1), within(-12350d, 0.001));
- assertThat(SqlFunctions.sround(-12345, -2), within(-12300d, 0.001));
- assertThat(SqlFunctions.sround(-12345, -3), within(-12000d, 0.001));
- assertThat(SqlFunctions.sround(-12000, -3), within(-12000d, 0.001));
- assertThat(SqlFunctions.sround(-11999, -3), within(-12000d, 0.001));
- assertThat(SqlFunctions.sround(-12000, -4), within(-10000d, 0.001));
- assertThat(SqlFunctions.sround(-12000, -5), within(0d, 0.001));
+ assertThat(SqlFunctions.sround(12345, -1), is(12350));
+ assertThat(SqlFunctions.sround(12345, -2), is(12300));
+ assertThat(SqlFunctions.sround(12345, -3), is(12000));
+ assertThat(SqlFunctions.sround(12000, -3), is(12000));
+ assertThat(SqlFunctions.sround(12001, -3), is(12000));
+ assertThat(SqlFunctions.sround(12000, -4), is(10000));
+ assertThat(SqlFunctions.sround(12000, -5), is(0));
+ assertThat(SqlFunctions.sround(11999, -3), is(12000));
+
+ assertThat(SqlFunctions.sround(-12345, -1), is(-12350));
+ assertThat(SqlFunctions.sround(-12345, -2), is(-12300));
+ assertThat(SqlFunctions.sround(-12345, -3), is(-12000));
+ assertThat(SqlFunctions.sround(-12000, -3), is(-12000));
+ assertThat(SqlFunctions.sround(-11999, -3), is(-12000));
+ assertThat(SqlFunctions.sround(-12000, -4), is(-10000));
+ assertThat(SqlFunctions.sround(-12000, -5), is(0));
}
@Test void testSplit() {
@@ -1417,51 +1419,53 @@ class SqlFunctionsTest {
final List<String> addc = Arrays.asList("a", "d", "c", "d", "c");
final List<String> z = Collections.emptyList();
assertThat(SqlFunctions.multisetExceptAll(abacee, addc),
- is(Arrays.asList("b", "a", "e", "e")));
+ isListOf("b", "a", "e", "e"));
assertThat(SqlFunctions.multisetExceptAll(abacee, z), is(abacee));
assertThat(SqlFunctions.multisetExceptAll(z, z), is(z));
assertThat(SqlFunctions.multisetExceptAll(z, addc), is(z));
assertThat(SqlFunctions.multisetExceptDistinct(abacee, addc),
- is(Arrays.asList("b", "e")));
+ isListOf("b", "e"));
assertThat(SqlFunctions.multisetExceptDistinct(abacee, z),
- is(Arrays.asList("a", "b", "c", "e")));
+ isListOf("a", "b", "c", "e"));
assertThat(SqlFunctions.multisetExceptDistinct(z, z), is(z));
assertThat(SqlFunctions.multisetExceptDistinct(z, addc), is(z));
+ Matcher<Object> result;
+ result = isListOf("a", "c");
assertThat(SqlFunctions.multisetIntersectAll(abacee, addc),
- is(Arrays.asList("a", "c")));
+ result);
assertThat(SqlFunctions.multisetIntersectAll(abacee, adaa),
- is(Arrays.asList("a", "a")));
+ isListOf("a", "a"));
assertThat(SqlFunctions.multisetIntersectAll(adaa, abacee),
- is(Arrays.asList("a", "a")));
+ isListOf("a", "a"));
assertThat(SqlFunctions.multisetIntersectAll(abacee, z), is(z));
assertThat(SqlFunctions.multisetIntersectAll(z, z), is(z));
assertThat(SqlFunctions.multisetIntersectAll(z, addc), is(z));
assertThat(SqlFunctions.multisetIntersectDistinct(abacee, addc),
- is(Arrays.asList("a", "c")));
+ isListOf("a", "c"));
assertThat(SqlFunctions.multisetIntersectDistinct(abacee, adaa),
- is(Collections.singletonList("a")));
+ isListOf("a"));
assertThat(SqlFunctions.multisetIntersectDistinct(adaa, abacee),
- is(Collections.singletonList("a")));
+ isListOf("a"));
assertThat(SqlFunctions.multisetIntersectDistinct(abacee, z), is(z));
assertThat(SqlFunctions.multisetIntersectDistinct(z, z), is(z));
assertThat(SqlFunctions.multisetIntersectDistinct(z, addc), is(z));
assertThat(SqlFunctions.multisetUnionAll(abacee, addc),
- is(Arrays.asList("a", "b", "a", "c", "e", "e", "a", "d", "c", "d", "c")));
+ isListOf("a", "b", "a", "c", "e", "e", "a", "d", "c", "d", "c"));
assertThat(SqlFunctions.multisetUnionAll(abacee, z), is(abacee));
assertThat(SqlFunctions.multisetUnionAll(z, z), is(z));
assertThat(SqlFunctions.multisetUnionAll(z, addc), is(addc));
assertThat(SqlFunctions.multisetUnionDistinct(abacee, addc),
- is(Arrays.asList("a", "b", "c", "d", "e")));
+ isListOf("a", "b", "c", "d", "e"));
assertThat(SqlFunctions.multisetUnionDistinct(abacee, z),
- is(Arrays.asList("a", "b", "c", "e")));
+ isListOf("a", "b", "c", "e"));
assertThat(SqlFunctions.multisetUnionDistinct(z, z), is(z));
assertThat(SqlFunctions.multisetUnionDistinct(z, addc),
- is(Arrays.asList("a", "c", "d")));
+ isListOf("a", "c", "d"));
}
@Test void testMd5() {
diff --git a/core/src/test/java/org/apache/calcite/test/SqlJsonFunctionsTest.java b/core/src/test/java/org/apache/calcite/test/SqlJsonFunctionsTest.java
index 2786eabcdd..0b69127160 100644
--- a/core/src/test/java/org/apache/calcite/test/SqlJsonFunctionsTest.java
+++ b/core/src/test/java/org/apache/calcite/test/SqlJsonFunctionsTest.java
@@ -45,6 +45,8 @@ import java.util.Objects;
import java.util.function.Supplier;
import java.util.stream.Collectors;
+import static org.apache.calcite.test.Matchers.isListOf;
+
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat;
@@ -424,7 +426,7 @@ class SqlJsonFunctionsTest {
SqlJsonQueryEmptyOrErrorBehavior.NULL,
SqlJsonQueryEmptyOrErrorBehavior.NULL,
false,
- is(Collections.singletonList("bar")));
+ isListOf("bar"));
assertJsonQuery(
JsonFunctions.JsonPathContext
.withUnknownException(new Exception("test message")),
diff --git a/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java b/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java
index 03b1a7e932..96f7d5c748 100644
--- a/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java
+++ b/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java
@@ -87,7 +87,6 @@ import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.hasToString;
-import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
@@ -2224,24 +2223,12 @@ public class SqlValidatorTest extends SqlValidatorTestCase {
// and ends with 5, this test is here to make sure that if someone
// changes how the time untis are setup, an early feedback will be
// generated by this test.
- assertEquals(
- 0,
- TimeUnit.YEAR.ordinal());
- assertEquals(
- 1,
- TimeUnit.MONTH.ordinal());
- assertEquals(
- 2,
- TimeUnit.DAY.ordinal());
- assertEquals(
- 3,
- TimeUnit.HOUR.ordinal());
- assertEquals(
- 4,
- TimeUnit.MINUTE.ordinal());
- assertEquals(
- 5,
- TimeUnit.SECOND.ordinal());
+ assertThat(TimeUnit.YEAR.ordinal(), is(0));
+ assertThat(TimeUnit.MONTH.ordinal(), is(1));
+ assertThat(TimeUnit.DAY.ordinal(), is(2));
+ assertThat(TimeUnit.HOUR.ordinal(), is(3));
+ assertThat(TimeUnit.MINUTE.ordinal(), is(4));
+ assertThat(TimeUnit.SECOND.ordinal(), is(5));
boolean b =
(TimeUnit.YEAR.ordinal()
< TimeUnit.MONTH.ordinal())
diff --git a/core/src/test/java/org/apache/calcite/test/fuzzer/RexProgramFuzzyTest.java b/core/src/test/java/org/apache/calcite/test/fuzzer/RexProgramFuzzyTest.java
index 997ec6ed84..ec351764dc 100644
--- a/core/src/test/java/org/apache/calcite/test/fuzzer/RexProgramFuzzyTest.java
+++ b/core/src/test/java/org/apache/calcite/test/fuzzer/RexProgramFuzzyTest.java
@@ -45,7 +45,8 @@ import java.util.PriorityQueue;
import java.util.Random;
import java.util.Set;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.fail;
/**
@@ -248,14 +249,16 @@ class RexProgramFuzzyTest extends RexProgramBuilderBase {
}
if (node.isAlwaysTrue()) {
if (!trueLiteral.equals(opt)) {
- assertEquals(trueLiteral, opt,
- () -> nodeToString(node) + " isAlwaysTrue, so it should simplify to TRUE " + uaf);
+ assertThat(nodeToString(node)
+ + " isAlwaysTrue, so it should simplify to TRUE " + uaf,
+ opt, is(trueLiteral));
}
}
if (node.isAlwaysFalse()) {
if (!falseLiteral.equals(opt)) {
- assertEquals(falseLiteral, opt,
- () -> nodeToString(node) + " isAlwaysFalse, so it should simplify to FALSE " + uaf);
+ assertThat(nodeToString(node)
+ + " isAlwaysFalse, so it should simplify to FALSE " + uaf,
+ opt, is(falseLiteral));
}
}
if (STRONG.isNull(node)) {
@@ -263,37 +266,42 @@ class RexProgramFuzzyTest extends RexProgramBuilderBase {
case FALSE:
if (node.getType().getSqlTypeName() == SqlTypeName.BOOLEAN) {
if (!falseLiteral.equals(opt)) {
- assertEquals(falseLiteral, opt,
- () -> nodeToString(node)
- + " is always null boolean, so it should simplify to FALSE " + uaf);
+ assertThat(nodeToString(node)
+ + " is always null boolean, so it should simplify to FALSE "
+ + uaf,
+ opt, is(falseLiteral));
}
} else {
if (!RexLiteral.isNullLiteral(opt)) {
- assertEquals(rexBuilder.makeNullLiteral(node.getType()), opt,
- () -> nodeToString(node)
- + " is always null (non boolean), so it should simplify to NULL " + uaf);
+ assertThat(nodeToString(node)
+ + " is always null (non boolean), so it should simplify to NULL "
+ + uaf,
+ opt, is(rexBuilder.makeNullLiteral(node.getType())));
}
}
break;
case TRUE:
if (node.getType().getSqlTypeName() == SqlTypeName.BOOLEAN) {
if (!trueLiteral.equals(opt)) {
- assertEquals(trueLiteral, opt,
- () -> nodeToString(node)
- + " is always null boolean, so it should simplify to TRUE " + uaf);
+ assertThat(nodeToString(node)
+ + " is always null boolean, so it should simplify to TRUE "
+ + uaf,
+ opt, is(trueLiteral));
}
} else {
if (!RexLiteral.isNullLiteral(opt)) {
- assertEquals(rexBuilder.makeNullLiteral(node.getType()), opt,
- () -> nodeToString(node)
- + " is always null (non boolean), so it should simplify to NULL " + uaf);
+ assertThat(nodeToString(node)
+ + " is always null (non boolean), so it should simplify to NULL "
+ + uaf,
+ opt, is(rexBuilder.makeNullLiteral(node.getType())));
}
}
break;
case UNKNOWN:
if (!RexUtil.isNull(opt)) {
- assertEquals(nullBool, opt,
- () -> nodeToString(node) + " is always null, so it should simplify to NULL " + uaf);
+ assertThat(nodeToString(node)
+ + " is always null, so it should simplify to NULL " + uaf,
+ opt, is(nullBool));
}
}
}
@@ -305,9 +313,10 @@ class RexProgramFuzzyTest extends RexProgramBuilderBase {
+ " that has nullable type " + opt.getType());
}
if (!SqlTypeUtil.equalSansNullability(typeFactory, node.getType(), opt.getType())) {
- assertEquals(node.getType(), opt.getType(),
- () -> nodeToString(node)
- + " has different type after simplification to " + nodeToString(opt));
+ assertThat(nodeToString(node)
+ + " has different type after simplification to "
+ + nodeToString(opt),
+ opt.getType(), is(node.getType()));
}
}
diff --git a/core/src/test/java/org/apache/calcite/tools/FrameworksTest.java b/core/src/test/java/org/apache/calcite/tools/FrameworksTest.java
index 35b1940472..97ef545fd3 100644
--- a/core/src/test/java/org/apache/calcite/tools/FrameworksTest.java
+++ b/core/src/test/java/org/apache/calcite/tools/FrameworksTest.java
@@ -89,7 +89,6 @@ import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.hasSize;
-import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.fail;
/**
@@ -187,7 +186,7 @@ public class FrameworksTest {
cluster.getRexBuilder().makeCall(SqlStdOperatorTable.PLUS,
literal,
literal);
- assertEquals(expected, call.getType().getPrecision());
+ assertThat(call.getType().getPrecision(), is(expected));
return null;
});
}
diff --git a/core/src/test/java/org/apache/calcite/tools/PlannerTest.java b/core/src/test/java/org/apache/calcite/tools/PlannerTest.java
index a57ec7fb2f..08abc8f751 100644
--- a/core/src/test/java/org/apache/calcite/tools/PlannerTest.java
+++ b/core/src/test/java/org/apache/calcite/tools/PlannerTest.java
@@ -102,7 +102,6 @@ import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.fail;
@@ -736,9 +735,10 @@ class PlannerTest {
RelNode convert = planner.rel(validate).rel;
RelDataType insertSourceType = convert.getInput(0).getRowType();
String typeString = SqlTests.getTypeString(insertSourceType);
- assertEquals("RecordType(INTEGER NOT NULL empid, INTEGER NOT NULL deptno, "
- + "JavaType(class java.lang.String) name, REAL NOT NULL salary, "
- + "INTEGER NOT NULL commission) NOT NULL", typeString);
+ assertThat(typeString,
+ is("RecordType(INTEGER NOT NULL empid, INTEGER NOT NULL deptno, "
+ + "JavaType(class java.lang.String) name, REAL NOT NULL salary, "
+ + "INTEGER NOT NULL commission) NOT NULL"));
}
/** Unit test that parses, validates, converts and plans. Planner is
diff --git a/core/src/test/java/org/apache/calcite/util/BitSetsTest.java b/core/src/test/java/org/apache/calcite/util/BitSetsTest.java
index 2bbe26bf78..9beab8308f 100644
--- a/core/src/test/java/org/apache/calcite/util/BitSetsTest.java
+++ b/core/src/test/java/org/apache/calcite/util/BitSetsTest.java
@@ -18,16 +18,18 @@ package org.apache.calcite.util;
import org.junit.jupiter.api.Test;
-import java.util.Arrays;
import java.util.BitSet;
import java.util.Collections;
import java.util.SortedMap;
import java.util.TreeMap;
+import static org.apache.calcite.test.Matchers.isListOf;
+
import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.empty;
import static org.hamcrest.Matchers.hasToString;
-import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
@@ -65,9 +67,9 @@ class BitSetsTest {
if (buf.length() > 0) {
buf.append(", ");
}
- buf.append(Integer.toString(i));
+ buf.append(i);
}
- assertEquals(expected, buf.toString());
+ assertThat(buf, hasToString(expected));
}
/**
@@ -76,38 +78,28 @@ class BitSetsTest {
*/
@Test void testToListBitSet() {
BitSet bitSet = new BitSet(10);
- assertEquals(BitSets.toList(bitSet), Collections.<Integer>emptyList());
+ assertThat(Collections.<Integer>emptyList(), is(BitSets.toList(bitSet)));
bitSet.set(5);
- assertEquals(BitSets.toList(bitSet), Arrays.asList(5));
+ assertThat(BitSets.toList(bitSet), isListOf(5));
bitSet.set(3);
- assertEquals(BitSets.toList(bitSet), Arrays.asList(3, 5));
+ assertThat(BitSets.toList(bitSet), isListOf(3, 5));
}
/**
* Tests the method {@link org.apache.calcite.util.BitSets#of(int...)}.
*/
@Test void testBitSetOf() {
- assertEquals(
- BitSets.toList(BitSets.of(0, 4, 2)),
- Arrays.asList(0, 2, 4));
- assertEquals(
- BitSets.toList(BitSets.of()),
- Collections.<Integer>emptyList());
+ assertThat(BitSets.toList(BitSets.of(0, 4, 2)), isListOf(0, 2, 4));
+ assertThat(BitSets.toList(BitSets.of()), empty());
}
/**
* Tests the method {@link org.apache.calcite.util.BitSets#range(int, int)}.
*/
@Test void testBitSetsRange() {
- assertEquals(
- BitSets.toList(BitSets.range(0, 4)),
- Arrays.asList(0, 1, 2, 3));
- assertEquals(
- BitSets.toList(BitSets.range(1, 4)),
- Arrays.asList(1, 2, 3));
- assertEquals(
- BitSets.toList(BitSets.range(2, 2)),
- Collections.<Integer>emptyList());
+ assertThat(BitSets.toList(BitSets.range(0, 4)), isListOf(0, 1, 2, 3));
+ assertThat(BitSets.toList(BitSets.range(1, 4)), isListOf(1, 2, 3));
+ assertThat(BitSets.toList(BitSets.range(2, 2)), empty());
}
/**
@@ -117,7 +109,7 @@ class BitSetsTest {
@Test void testBitSetsToArray() {
int[][] arrays = {{}, {0}, {0, 2}, {1, 65}, {100}};
for (int[] array : arrays) {
- assertThat(BitSets.toArray(BitSets.of(array)), equalTo(array));
+ assertThat(BitSets.toArray(BitSets.of(array)), is(array));
}
}
@@ -192,7 +184,7 @@ class BitSetsTest {
final SortedMap<Integer, BitSet> empty = new TreeMap<>();
assertThat(BitSets.closure(empty), equalTo(empty));
- // Map with an an entry for each position.
+ // Map with an entry for each position.
final SortedMap<Integer, BitSet> map = new TreeMap<>();
map.put(0, BitSets.of(3));
map.put(1, BitSets.of());
diff --git a/core/src/test/java/org/apache/calcite/util/ChunkListTest.java b/core/src/test/java/org/apache/calcite/util/ChunkListTest.java
index 7923ddd97e..a7a2677e8e 100644
--- a/core/src/test/java/org/apache/calcite/util/ChunkListTest.java
+++ b/core/src/test/java/org/apache/calcite/util/ChunkListTest.java
@@ -33,7 +33,7 @@ import java.util.Random;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.hasSize;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.Matchers.hasToString;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -51,11 +51,11 @@ class ChunkListTest {
final ChunkList<Integer> list0 = new ChunkList<>(list);
final ChunkList<Integer> list1 = new ChunkList<>(list);
list1.add(123);
- assertEquals(0, list.size());
- assertEquals(0, list0.size());
- assertEquals(1, list1.size());
+ assertThat(list, hasSize(0));
+ assertThat(list0, hasSize(0));
+ assertThat(list1, hasSize(1));
assertTrue(list.isEmpty());
- assertEquals("[]", list.toString());
+ assertThat(list, hasToString("[]"));
try {
list.remove(0);
@@ -79,45 +79,45 @@ class ChunkListTest {
}
list.add(7);
- assertEquals(1, list.size());
- assertEquals(7, (int) list.get(0));
+ assertThat(list, hasSize(1));
+ assertThat(list.get(0), is(7));
assertFalse(list.isEmpty());
- assertEquals("[7]", list.toString());
+ assertThat(list, hasToString("[7]"));
list.add(9);
list.add(null);
list.add(11);
- assertEquals(4, list.size());
- assertEquals(7, (int) list.get(0));
- assertEquals(9, (int) list.get(1));
+ assertThat(list, hasSize(4));
+ assertThat(list.get(0), is(7));
+ assertThat(list.get(1), is(9));
assertNull(list.get(2));
- assertEquals(11, (int) list.get(3));
+ assertThat(list.get(3), is(11));
assertFalse(list.isEmpty());
- assertEquals("[7, 9, null, 11]", list.toString());
+ assertThat(list, hasToString("[7, 9, null, 11]"));
assertTrue(list.contains(9));
assertFalse(list.contains(8));
list.addAll(Collections.nCopies(70, 1));
- assertEquals(74, list.size());
- assertEquals(1, (int) list.get(40));
- assertEquals(1, (int) list.get(70));
+ assertThat(list, hasSize(74));
+ assertThat((int) list.get(40), is(1));
+ assertThat((int) list.get(70), is(1));
int n = 0;
for (Integer integer : list) {
Util.discard(integer);
++n;
}
- assertEquals(n, list.size());
+ assertThat(list, hasSize(n));
int i = list.indexOf(null);
- assertEquals(2, i);
+ assertThat(i, is(2));
// can't sort if null is present
list.set(2, 123);
i = list.indexOf(null);
- assertEquals(-1, i);
+ assertThat(i, is(-1));
// sort an empty list
Collections.sort(list0);
@@ -128,11 +128,11 @@ class ChunkListTest {
assertThat(list1, hasSize(1));
Collections.sort(list);
- assertEquals(74, list.size());
+ assertThat(list, hasSize(74));
list.remove((Integer) 7);
Collections.sort(list);
- assertEquals(1, (int) list.get(3));
+ assertThat((int) list.get(3), is(1));
// remove all instances of a value that exists
boolean b = list.removeAll(Collections.singletonList(9));
@@ -161,14 +161,14 @@ class ChunkListTest {
//noinspection MismatchedQueryAndUpdateOfCollection
final ChunkList<String> list2 = new ChunkList<>();
list2.listIterator(0).add("x");
- assertEquals("[x]", list2.toString());
+ assertThat(list2, hasToString("[x]"));
// add at start
list2.add(0, "y");
- assertEquals("[y, x]", list2.toString());
+ assertThat(list2, hasToString("[y, x]"));
list2.remove(0);
- assertEquals("[x]", list2.toString());
+ assertThat(list2, hasToString("[x]"));
// clear a list of length 5, one element at a time, using an iterator
list2.clear();
@@ -325,8 +325,8 @@ class ChunkListTest {
assertTrue(list.size() < size);
assertTrue(list2.size() < size);
} else {
- assertTrue(list.size() == size);
- assertTrue(list2.size() == size);
+ assertThat(list, hasSize(size));
+ assertThat(list2, hasSize(size));
}
removeCount += size - list.size();
break;
@@ -370,8 +370,8 @@ class ChunkListTest {
++addCount;
break;
}
- assertEquals(list.size(), initialCount + addCount - removeCount);
- assertEquals(list, list2);
+ assertThat(initialCount + addCount - removeCount, is(list.size()));
+ assertThat(list2, is(list));
}
}
diff --git a/core/src/test/java/org/apache/calcite/util/FormatModelTest.java b/core/src/test/java/org/apache/calcite/util/FormatModelTest.java
index c43300690e..a2bb9e968f 100644
--- a/core/src/test/java/org/apache/calcite/util/FormatModelTest.java
+++ b/core/src/test/java/org/apache/calcite/util/FormatModelTest.java
@@ -24,11 +24,10 @@ import org.hamcrest.Matcher;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
import java.util.List;
-import static org.hamcrest.CoreMatchers.is;
+import static org.apache.calcite.test.Matchers.isListOf;
+
import static org.hamcrest.MatcherAssert.assertThat;
/**
@@ -37,7 +36,7 @@ import static org.hamcrest.MatcherAssert.assertThat;
public class FormatModelTest {
private void assertThatFormatElementParse(String formatString,
- Matcher<List<String>> matcher) {
+ Matcher<? super List<String>> matcher) {
List<FormatElement> elements = FormatModels.BIG_QUERY.parse(formatString);
List<String> stringResults = new ArrayList<>();
for (FormatElement element : elements) {
@@ -47,21 +46,21 @@ public class FormatModelTest {
}
@Test void testSingleElement() {
- assertThatFormatElementParse("%j", is(Collections.singletonList("DDD")));
+ assertThatFormatElementParse("%j", isListOf("DDD"));
}
@Test void testMultipleElements() {
assertThatFormatElementParse("%b-%d-%Y",
- is(Arrays.asList("Mon", "-", "DD", "-", "pctY")));
+ isListOf("Mon", "-", "DD", "-", "pctY"));
}
@Test void testArbitraryText() {
assertThatFormatElementParse("%jtext%b",
- is(Arrays.asList("DDD", "text", "Mon")));
+ isListOf("DDD", "text", "Mon"));
}
@Test void testAliasText() {
assertThatFormatElementParse("%R",
- is(Arrays.asList("HH24", ":", "MI")));
+ isListOf("HH24", ":", "MI"));
}
}
diff --git a/core/src/test/java/org/apache/calcite/util/ImmutableBitSetTest.java b/core/src/test/java/org/apache/calcite/util/ImmutableBitSetTest.java
index 35f307a674..260af704c5 100644
--- a/core/src/test/java/org/apache/calcite/util/ImmutableBitSetTest.java
+++ b/core/src/test/java/org/apache/calcite/util/ImmutableBitSetTest.java
@@ -45,7 +45,6 @@ import static org.hamcrest.CoreMatchers.sameInstance;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.hasSize;
import static org.hamcrest.Matchers.hasToString;
-import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertSame;
@@ -123,7 +122,7 @@ class ImmutableBitSetTest {
}
buf.append(i);
}
- assertEquals(expected, buf.toString());
+ assertThat(buf, hasToString(expected));
}
/**
@@ -173,16 +172,15 @@ class ImmutableBitSetTest {
* Tests the method {@link BitSets#range(int, int)}.
*/
@Test void testRange() {
- assertEquals(ImmutableBitSet.range(0, 4).toList(),
- Arrays.asList(0, 1, 2, 3));
- assertEquals(ImmutableBitSet.range(1, 4).toList(),
- Arrays.asList(1, 2, 3));
- assertEquals(ImmutableBitSet.range(4).toList(),
- Arrays.asList(0, 1, 2, 3));
- assertEquals(ImmutableBitSet.range(0).toList(),
- Collections.<Integer>emptyList());
- assertEquals(ImmutableBitSet.range(2, 2).toList(),
- Collections.<Integer>emptyList());
+ final List<Integer> list0123 = Arrays.asList(0, 1, 2, 3);
+ final List<Integer> list123 = Arrays.asList(1, 2, 3);
+ final List<Integer> listEmpty = Collections.emptyList();
+
+ assertThat(ImmutableBitSet.range(0, 4).toList(), is(list0123));
+ assertThat(ImmutableBitSet.range(1, 4).toList(), is(list123));
+ assertThat(ImmutableBitSet.range(4).toList(), is(list0123));
+ assertThat(ImmutableBitSet.range(0).toList(), is(listEmpty));
+ assertThat(ImmutableBitSet.range(2, 2).toList(), is(listEmpty));
assertThat(ImmutableBitSet.range(63, 66),
hasToString("{63, 64, 65}"));
@@ -224,10 +222,10 @@ class ImmutableBitSetTest {
if (c == 0) {
assertTrue(i == j || i == 3 && j == 4 || i == 4 && j == 3);
} else {
- assertEquals(c, Utilities.compare(i, j));
+ assertThat(Utilities.compare(i, j), is(c));
}
- assertEquals(c == 0, set0.equals(set1));
- assertEquals(c == 0, set1.equals(set0));
+ assertThat(set0.equals(set1), is(c == 0));
+ assertThat(set1.equals(set0), is(c == 0));
}
}
}
@@ -414,8 +412,8 @@ class ImmutableBitSetTest {
final ImmutableBitSet fives3 =
ImmutableBitSet.builder().addAll(fives).clear(2).set(10).build();
assertNotSame(fives3, fives);
- assertEquals(fives3, fives);
- assertEquals(fives3, fives2);
+ assertThat(fives, is(fives3));
+ assertThat(fives2, is(fives3));
}
@Test void testIndexOf() {
diff --git a/core/src/test/java/org/apache/calcite/util/PairListTest.java b/core/src/test/java/org/apache/calcite/util/PairListTest.java
index 1bafc852fb..5380d408b7 100644
--- a/core/src/test/java/org/apache/calcite/util/PairListTest.java
+++ b/core/src/test/java/org/apache/calcite/util/PairListTest.java
@@ -34,6 +34,8 @@ import java.util.Map;
import java.util.RandomAccess;
import java.util.function.BiPredicate;
+import static org.apache.calcite.test.Matchers.isListOf;
+
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
@@ -276,7 +278,7 @@ class PairListTest {
final ImmutableMap<String, Integer> map = ImmutableMap.of("a", 1, "b", 2);
final PairList<String, Integer> pairList = PairList.of(map);
assertThat(pairList, hasSize(2));
- assertThat(pairList.toString(), is("[<a, 1>, <b, 2>]"));
+ assertThat(pairList, hasToString("[<a, 1>, <b, 2>]"));
final List<Map.Entry<String, Integer>> list = new ArrayList<>(map.entrySet());
validate(pairList, list);
@@ -289,9 +291,9 @@ class PairListTest {
pairList.add("c", 3);
list.add(Pair.of("c", 3));
validate(pairList, list);
- assertThat(pairList.toString(), is("[<a, 1>, <b, 2>, <c, 3>]"));
+ assertThat(pairList, hasToString("[<a, 1>, <b, 2>, <c, 3>]"));
final ImmutableMap<String, Integer> map3 = pairList.toImmutableMap();
- assertThat(map3.toString(), is("{a=1, b=2, c=3}"));
+ assertThat(map3, hasToString("{a=1, b=2, c=3}"));
final Map<String, Integer> emptyMap = ImmutableMap.of();
final PairList<String, Integer> emptyPairList = PairList.of(emptyMap);
@@ -341,9 +343,9 @@ class PairListTest {
final PairList<String, Integer> list3 =
PairList.copyOf("a", 1, null, 5, "c", 3);
assertThat(list3.transform((s, i) -> s + i),
- is(Arrays.asList("a1", "null5", "c3")));
+ isListOf("a1", "null5", "c3"));
assertThat(list3.transform2((s, i) -> s + i),
- is(Arrays.asList("a1", "null5", "c3")));
+ isListOf("a1", "null5", "c3"));
final PairList<String, Integer> list0 = PairList.of();
assertThat(list0.transform((s, i) -> s + i), empty());
diff --git a/core/src/test/java/org/apache/calcite/util/PartiallyOrderedSetTest.java b/core/src/test/java/org/apache/calcite/util/PartiallyOrderedSetTest.java
index a16d91f23a..05a48fde57 100644
--- a/core/src/test/java/org/apache/calcite/util/PartiallyOrderedSetTest.java
+++ b/core/src/test/java/org/apache/calcite/util/PartiallyOrderedSetTest.java
@@ -31,8 +31,9 @@ import java.util.function.Function;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.empty;
import static org.hamcrest.Matchers.hasSize;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.Matchers.hasToString;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static java.util.Objects.requireNonNull;
@@ -88,7 +89,7 @@ class PartiallyOrderedSetTest {
String abcd = "'abcd'";
final PartiallyOrderedSet<String> poset =
new PartiallyOrderedSet<>(STRING_SUBSET_ORDERING);
- assertEquals(0, poset.size());
+ assertThat(poset, hasSize(0));
final StringBuilder buf = new StringBuilder();
poset.out(buf);
@@ -103,41 +104,41 @@ class PartiallyOrderedSetTest {
printValidate(poset);
poset.clear();
- assertEquals(0, poset.size());
+ assertThat(poset, hasSize(0));
poset.add(empty);
printValidate(poset);
poset.add(abcd);
printValidate(poset);
- assertEquals(2, poset.size());
- assertEquals("['abcd']", poset.getNonChildren().toString());
- assertEquals("['']", poset.getNonParents().toString());
+ assertThat(poset, hasSize(2));
+ assertThat(poset.getNonChildren(), hasToString("['abcd']"));
+ assertThat(poset.getNonParents(), hasToString("['']"));
final String ab = "'ab'";
poset.add(ab);
printValidate(poset);
- assertEquals(3, poset.size());
- assertEquals("[]", poset.getChildren(empty).toString());
- assertEquals("['ab']", poset.getParents(empty).toString());
- assertEquals("['ab']", poset.getChildren(abcd).toString());
- assertEquals("[]", poset.getParents(abcd).toString());
- assertEquals("['']", poset.getChildren(ab).toString());
- assertEquals("['abcd']", poset.getParents(ab).toString());
+ assertThat(poset, hasSize(3));
+ assertThat(poset.getChildren(empty), hasToString("[]"));
+ assertThat(poset.getParents(empty), hasToString("['ab']"));
+ assertThat(poset.getChildren(abcd), hasToString("['ab']"));
+ assertThat(poset.getParents(abcd), hasToString("[]"));
+ assertThat(poset.getChildren(ab), hasToString("['']"));
+ assertThat(poset.getParents(ab), hasToString("['abcd']"));
// "bcd" is child of "abcd" and parent of ""
final String bcd = "'bcd'";
- assertEquals("['abcd']", poset.getParents(bcd, true).toString());
+ assertThat(poset.getParents(bcd, true), hasToString("['abcd']"));
assertThat(poset.getParents(bcd, false), nullValue());
assertThat(poset.getParents(bcd), nullValue());
- assertEquals("['']", poset.getChildren(bcd, true).toString());
+ assertThat(poset.getChildren(bcd, true), hasToString("['']"));
assertThat(poset.getChildren(bcd, false), nullValue());
assertThat(poset.getChildren(bcd), nullValue());
poset.add(bcd);
printValidate(poset);
assertTrue(poset.isValid(false));
- assertEquals("['']", poset.getChildren(bcd).toString());
- assertEquals("['abcd']", poset.getParents(bcd).toString());
- assertEquals("['ab', 'bcd']", poset.getChildren(abcd).toString());
+ assertThat(poset.getChildren(bcd), hasToString("['']"));
+ assertThat(poset.getParents(bcd), hasToString("['abcd']"));
+ assertThat(poset.getChildren(abcd), hasToString("['ab', 'bcd']"));
buf.setLength(0);
poset.out(buf);
@@ -157,18 +158,18 @@ class PartiallyOrderedSetTest {
poset.add(b);
printValidate(poset);
- assertEquals("['abcd']", poset.getNonChildren().toString());
- assertEquals("['']", poset.getNonParents().toString());
- assertEquals("['']", poset.getChildren(b).toString());
+ assertThat(poset.getNonChildren(), hasToString("['abcd']"));
+ assertThat(poset.getNonParents(), hasToString("['']"));
+ assertThat(poset.getChildren(b), hasToString("['']"));
assertEqualsList("['ab', 'bcd']", poset.getParents(b));
- assertEquals("['']", poset.getChildren(b).toString());
- assertEquals("['ab', 'bcd']", poset.getChildren(abcd).toString());
- assertEquals("['b']", poset.getChildren(bcd).toString());
- assertEquals("['b']", poset.getChildren(ab).toString());
+ assertThat(poset.getChildren(b), hasToString("['']"));
+ assertThat(poset.getChildren(abcd), hasToString("['ab', 'bcd']"));
+ assertThat(poset.getChildren(bcd), hasToString("['b']"));
+ assertThat(poset.getChildren(ab), hasToString("['b']"));
assertEqualsList("['ab', 'abcd', 'bcd']", poset.getAncestors(b));
// descendants and ancestors of an element with no descendants
- assertEquals("[]", poset.getDescendants(empty).toString());
+ assertThat(poset.getDescendants(empty), hasToString("[]"));
assertEqualsList(
"['ab', 'abcd', 'b', 'bcd']",
poset.getAncestors(empty));
@@ -282,17 +283,13 @@ class PartiallyOrderedSetTest {
PartiallyOrderedSet<Integer> integers =
new PartiallyOrderedSet<>(PartiallyOrderedSetTest::isDivisor,
range(1, 1000));
- assertEquals(
- "[1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 20, 24, 30, 40, 60]",
- new TreeSet<>(integers.getDescendants(120)).toString());
- assertEquals(
- "[240, 360, 480, 600, 720, 840, 960]",
- new TreeSet<>(integers.getAncestors(120)).toString());
- assertTrue(integers.getDescendants(1).isEmpty());
- assertEquals(
- 998,
- integers.getAncestors(1).size());
- assertTrue(integers.isValid(true));
+ assertThat(new TreeSet<>(integers.getDescendants(120)),
+ hasToString("[1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 20, 24, 30, 40, 60]"));
+ assertThat(new TreeSet<>(integers.getAncestors(120)),
+ hasToString("[240, 360, 480, 600, 720, 840, 960]"));
+ assertThat(integers.getDescendants(1), empty());
+ assertThat(integers.getAncestors(1), hasSize(998));
+ assertThat(integers.isValid(true), is(true));
}
@Test void testDivisorSeries() {
@@ -411,7 +408,7 @@ class PartiallyOrderedSetTest {
if (debug) {
dump(poset);
}
- assertEquals(++n, poset.size());
+ assertThat(poset, hasSize(++n));
if (i < 100) {
if (!poset.isValid(false)) {
dump(poset);
@@ -455,7 +452,7 @@ class PartiallyOrderedSetTest {
}
private static void assertEqualsList(String expected, List<String> ss) {
- assertEquals(expected, new TreeSet<>(ss).toString());
+ assertThat(new TreeSet<>(ss), hasToString(expected));
}
}
diff --git a/core/src/test/java/org/apache/calcite/util/PermutationTestCase.java b/core/src/test/java/org/apache/calcite/util/PermutationTestCase.java
index 1b297bd624..d750675a3e 100644
--- a/core/src/test/java/org/apache/calcite/util/PermutationTestCase.java
+++ b/core/src/test/java/org/apache/calcite/util/PermutationTestCase.java
@@ -28,9 +28,11 @@ import com.google.common.collect.ImmutableList;
import org.junit.jupiter.api.Test;
import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.hasToString;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
@@ -41,106 +43,72 @@ import static org.junit.jupiter.api.Assertions.fail;
class PermutationTestCase {
@Test void testOne() {
final Permutation perm = new Permutation(4);
- assertEquals(
- "[0, 1, 2, 3]",
- perm.toString());
- assertEquals(
- 4,
- perm.size());
+ assertThat(perm, hasToString("[0, 1, 2, 3]"));
+ assertThat(perm.size(), hasToString("4"));
perm.set(0, 2);
- assertEquals(
- "[2, 1, 0, 3]",
- perm.toString());
+ assertThat(perm, hasToString("[2, 1, 0, 3]"));
perm.set(1, 0);
- assertEquals(
- "[2, 0, 1, 3]",
- perm.toString());
+ assertThat(perm, hasToString("[2, 0, 1, 3]"));
final Permutation invPerm = perm.inverse();
- assertEquals(
- "[1, 2, 0, 3]",
- invPerm.toString());
+ assertThat(invPerm, hasToString("[1, 2, 0, 3]"));
// changing perm doesn't change inverse
perm.set(0, 0);
- assertEquals(
- "[0, 2, 1, 3]",
- perm.toString());
- assertEquals(
- "[1, 2, 0, 3]",
- invPerm.toString());
+ assertThat(perm, hasToString("[0, 2, 1, 3]"));
+ assertThat(invPerm, hasToString("[1, 2, 0, 3]"));
}
@Test void testTwo() {
final Permutation perm = new Permutation(new int[]{3, 2, 0, 1});
assertFalse(perm.isIdentity());
- assertEquals(
- "[3, 2, 0, 1]",
- perm.toString());
+ assertThat(perm, hasToString("[3, 2, 0, 1]"));
Permutation perm2 = (Permutation) perm.clone();
- assertEquals(
- "[3, 2, 0, 1]",
- perm2.toString());
- assertTrue(perm.equals(perm2));
- assertTrue(perm2.equals(perm));
+ assertThat(perm2, hasToString("[3, 2, 0, 1]"));
+ assertThat(perm, is(perm2));
+ assertThat(perm2, is(perm));
perm.set(2, 1);
- assertEquals(
- "[3, 2, 1, 0]",
- perm.toString());
- assertFalse(perm.equals(perm2));
+ assertThat(perm, hasToString("[3, 2, 1, 0]"));
+ assertThat(perm, not(equalTo(perm2)));
// clone not affected
- assertEquals(
- "[3, 2, 0, 1]",
- perm2.toString());
+ assertThat(perm2, hasToString("[3, 2, 0, 1]"));
perm2.set(2, 3);
- assertEquals(
- "[0, 2, 3, 1]",
- perm2.toString());
+ assertThat(perm2, hasToString("[0, 2, 3, 1]"));
}
@Test void testInsert() {
Permutation perm = new Permutation(new int[]{3, 0, 4, 2, 1});
perm.insertTarget(2);
- assertEquals(
- "[4, 0, 5, 3, 1, 2]",
- perm.toString());
+ assertThat(perm, hasToString("[4, 0, 5, 3, 1, 2]"));
// insert at start
perm = new Permutation(new int[]{3, 0, 4, 2, 1});
perm.insertTarget(0);
- assertEquals(
- "[4, 1, 5, 3, 2, 0]",
- perm.toString());
+ assertThat(perm, hasToString("[4, 1, 5, 3, 2, 0]"));
// insert at end
perm = new Permutation(new int[]{3, 0, 4, 2, 1});
perm.insertTarget(5);
- assertEquals(
- "[3, 0, 4, 2, 1, 5]",
- perm.toString());
+ assertThat(perm, hasToString("[3, 0, 4, 2, 1, 5]"));
// insert into empty
perm = new Permutation(new int[]{});
perm.insertTarget(0);
- assertEquals(
- "[0]",
- perm.toString());
+ assertThat(perm, hasToString("[0]"));
}
@Test void testEmpty() {
final Permutation perm = new Permutation(0);
assertTrue(perm.isIdentity());
- assertEquals(
- "[]",
- perm.toString());
- assertTrue(perm.equals(perm));
- assertTrue(perm.equals(perm.inverse()));
+ assertThat(perm, hasToString("[]"));
+ assertThat(perm, is(perm));
+ assertThat(perm, is(perm.inverse()));
try {
perm.set(1, 0);
diff --git a/core/src/test/java/org/apache/calcite/util/ReflectVisitorTest.java b/core/src/test/java/org/apache/calcite/util/ReflectVisitorTest.java
index 9fe2e045e9..1ea1fce3bd 100644
--- a/core/src/test/java/org/apache/calcite/util/ReflectVisitorTest.java
+++ b/core/src/test/java/org/apache/calcite/util/ReflectVisitorTest.java
@@ -20,7 +20,11 @@ import org.junit.jupiter.api.Test;
import java.math.BigDecimal;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.nullValue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.closeTo;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
@@ -39,9 +43,7 @@ class ReflectVisitorTest {
// verify that negater is capable of handling integers
result = negater.negate(5);
- assertEquals(
- -5,
- result.intValue());
+ assertThat(result.intValue(), is(-5));
}
/**
@@ -54,18 +56,14 @@ class ReflectVisitorTest {
// verify that negater is capable of handling integers,
// and that result comes back with same type
result = negater.negate(5);
- assertEquals(
- -5,
- result.intValue());
- assertTrue(result instanceof Integer);
+ assertThat(result.intValue(), is(-5));
+ assertThat(result, instanceOf(Integer.class));
// verify that negater is capable of handling longs;
// even though it doesn't provide an explicit implementation,
// it should inherit the one from CarelessNumberNegater
result = negater.negate(5L);
- assertEquals(
- -5L,
- result.longValue());
+ assertThat(result.longValue(), is(-5L));
}
/**
@@ -78,14 +76,12 @@ class ReflectVisitorTest {
// verify that negater is capable of handling shorts,
// and that result comes back with same type
result = negater.negate((short) 5);
- assertEquals(
- -5,
- result.shortValue());
- assertTrue(result instanceof Short);
+ assertThat(result.shortValue(), is((short) -5));
+ assertThat(result, instanceOf(Short.class));
// verify that negater is NOT capable of handling integers
result = negater.negate(5);
- assertEquals(null, result);
+ assertThat(result, nullValue());
}
/**
@@ -114,10 +110,7 @@ class ReflectVisitorTest {
Number result;
result = negater.negate(new SomewhatAmbiguousNumber());
- assertEquals(
- 0.0,
- result.doubleValue(),
- 0.001);
+ assertThat(result.doubleValue(), closeTo(0.0, 0.001));
}
//~ Inner Interfaces -------------------------------------------------------
diff --git a/core/src/test/java/org/apache/calcite/util/SourceTest.java b/core/src/test/java/org/apache/calcite/util/SourceTest.java
index 4f4f775ebf..6715a3622a 100644
--- a/core/src/test/java/org/apache/calcite/util/SourceTest.java
+++ b/core/src/test/java/org/apache/calcite/util/SourceTest.java
@@ -41,7 +41,6 @@ import static org.apache.calcite.util.Sources.url;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.hasToString;
-import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.params.provider.Arguments.arguments;
@@ -70,8 +69,8 @@ class SourceTest {
for (Reader r : Arrays.asList(source.reader(),
new InputStreamReader(source.openStream(), StandardCharsets.UTF_8.name()))) {
try (BufferedReader reader = new BufferedReader(r)) {
- assertEquals("a", reader.readLine());
- assertEquals("b", reader.readLine());
+ assertThat(reader.readLine(), is("a"));
+ assertThat(reader.readLine(), is("b"));
assertNull(reader.readLine());
}
}
@@ -96,10 +95,11 @@ class SourceTest {
URL url = of(new File(path)).url();
assertNotNull(url, () -> "No URL generated for Sources.of(file " + path + ")");
- assertEquals(expectedUrl, url.toString(),
- () -> "Sources.of(file " + path + ").url()");
- assertEquals(path, slashify(Sources.of(url).file().getPath()),
- () -> "Sources.of(Sources.of(file " + path + ").url()).file().getPath()");
+ assertThat("Sources.of(file " + path + ").url()", url,
+ hasToString(expectedUrl));
+ assertThat("Sources.of(Sources.of(file " + path
+ + ").url()).file().getPath()",
+ slashify(Sources.of(url).file().getPath()), is(path));
}
@ParameterizedTest
@@ -114,8 +114,10 @@ class SourceTest {
// e.g. it might throw java.nio.file.InvalidPathException: Malformed input or input contains
// unmappable characters: /home/.../ws/core/????????? ?????? ??????? ?????.txt
// at java.base/sun.nio.fs.UnixPath.encode(UnixPath.java:145)
- assertEquals(absoluteFile.getAbsolutePath(), url.toURI().getSchemeSpecificPart(),
- () -> "Sources.of(Sources.of(file(" + path + ").absolutePath).url()).file().getPath()");
+ assertThat("Sources.of(Sources.of(file(" + path
+ + ").absolutePath).url()).file().getPath()",
+ url.toURI().getSchemeSpecificPart(),
+ is(absoluteFile.getAbsolutePath()));
}
@Test void testAppendWithSpaces() {
@@ -176,17 +178,18 @@ class SourceTest {
@Test void testSpaceInUrl() {
String url = "file:" + ROOT_PREFIX + "dir%20name/test%20file.json";
final Source foo = url(url);
- assertEquals(new File(ROOT_PREFIX + "dir name/test file.json").getAbsolutePath(),
+ assertThat(url + " .file().getAbsolutePath()",
foo.file().getAbsolutePath(),
- () -> url + " .file().getAbsolutePath()");
+ is(new File(ROOT_PREFIX + "dir name/test file.json")
+ .getAbsolutePath()));
}
@Test void testSpaceInRelativeUrl() {
String url = "file:dir%20name/test%20file.json";
final Source foo = url(url);
- assertEquals("dir name/test file.json",
+ assertThat(url + " .file().getAbsolutePath()",
foo.file().getPath().replace('\\', '/'),
- () -> url + " .file().getAbsolutePath()");
+ is("dir name/test file.json"));
}
@Test void testRelative() {
diff --git a/core/src/test/java/org/apache/calcite/util/UtilTest.java b/core/src/test/java/org/apache/calcite/util/UtilTest.java
index 94456f89ed..a39a541d9d 100644
--- a/core/src/test/java/org/apache/calcite/util/UtilTest.java
+++ b/core/src/test/java/org/apache/calcite/util/UtilTest.java
@@ -107,6 +107,7 @@ import java.util.function.Supplier;
import java.util.function.UnaryOperator;
import static org.apache.calcite.test.Matchers.isLinux;
+import static org.apache.calcite.test.Matchers.isListOf;
import static org.apache.calcite.util.ReflectUtil.isStatic;
import static org.apache.calcite.util.TestUtil.assertThatScientific;
@@ -123,9 +124,11 @@ import static org.hamcrest.CoreMatchers.sameInstance;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.aMapWithSize;
+import static org.hamcrest.Matchers.arrayWithSize;
+import static org.hamcrest.Matchers.empty;
+import static org.hamcrest.Matchers.emptyString;
import static org.hamcrest.Matchers.hasSize;
import static org.hamcrest.Matchers.hasToString;
-import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotSame;
@@ -237,48 +240,30 @@ class UtilTest {
}
@Test void testToJavaId() throws UnsupportedEncodingException {
- assertEquals(
- "ID$0$foo",
- Util.toJavaId("foo", 0));
- assertEquals(
- "ID$0$foo_20_bar",
- Util.toJavaId("foo bar", 0));
- assertEquals(
- "ID$0$foo__bar",
- Util.toJavaId("foo_bar", 0));
- assertEquals(
- "ID$100$_30_bar",
- Util.toJavaId("0bar", 100));
- assertEquals(
- "ID$0$foo0bar",
- Util.toJavaId("foo0bar", 0));
- assertEquals(
- "ID$0$it_27_s_20_a_20_bird_2c__20_it_27_s_20_a_20_plane_21_",
- Util.toJavaId("it's a bird, it's a plane!", 0));
+ assertThat(Util.toJavaId("foo", 0), is("ID$0$foo"));
+ assertThat(Util.toJavaId("foo bar", 0), is("ID$0$foo_20_bar"));
+ assertThat(Util.toJavaId("foo_bar", 0), is("ID$0$foo__bar"));
+ assertThat(Util.toJavaId("0bar", 100), is("ID$100$_30_bar"));
+ assertThat(Util.toJavaId("foo0bar", 0), is("ID$0$foo0bar"));
+ assertThat(Util.toJavaId("it's a bird, it's a plane!", 0),
+ is("ID$0$it_27_s_20_a_20_bird_2c__20_it_27_s_20_a_20_plane_21_"));
// Try some funny non-ASCII charsets
- assertEquals(
- "ID$0$_f6__cb__c4__ca__ae__c1__f9__cb_",
- Util.toJavaId(
- "\u00f6\u00cb\u00c4\u00ca\u00ae\u00c1\u00f9\u00cb",
- 0));
- assertEquals(
- "ID$0$_f6cb__c4ca__aec1__f9cb_",
- Util.toJavaId("\uf6cb\uc4ca\uaec1\uf9cb", 0));
+ assertThat(
+ Util.toJavaId("\u00f6\u00cb\u00c4\u00ca\u00ae\u00c1\u00f9\u00cb", 0),
+ is("ID$0$_f6__cb__c4__ca__ae__c1__f9__cb_"));
+ assertThat(Util.toJavaId("\uf6cb\uc4ca\uaec1\uf9cb", 0),
+ is("ID$0$_f6cb__c4ca__aec1__f9cb_"));
byte[] bytes1 = {3, 12, 54, 23, 33, 23, 45, 21, 127, -34, -92, -113};
- assertEquals(
- "ID$0$_3__c_6_17__21__17__2d__15__7f__6cd9__fffd_",
- Util.toJavaId(
- new String(bytes1, "EUC-JP"), // CHECKSTYLE: IGNORE 0
- 0));
+ assertThat(
+ Util.toJavaId(new String(bytes1, "EUC-JP"), 0), // CHECKSTYLE: IGNORE 0
+ is("ID$0$_3__c_6_17__21__17__2d__15__7f__6cd9__fffd_"));
byte[] bytes2 = {
64, 32, 43, -45, -23, 0, 43, 54, 119, -32, -56, -34
};
- assertEquals(
- "ID$0$_30c__3617__2117__2d15__7fde__a48f_",
- Util.toJavaId(
- new String(bytes1, "UTF-16"), // CHECKSTYLE: IGNORE 0
- 0));
+ assertThat(
+ Util.toJavaId(new String(bytes1, "UTF-16"), 0), // CHECKSTYLE: IGNORE 0
+ is("ID$0$_30c__3617__2117__2d15__7fde__a48f_"));
}
private void assertPrintEquals(
@@ -290,7 +275,7 @@ class UtilTest {
Util.printJavaString(pw, in, nullMeansNull);
pw.flush();
String out = sw.toString();
- assertEquals(expect, out);
+ assertThat(out, is(expect));
}
/**
@@ -326,40 +311,18 @@ class UtilTest {
final BitString b0x12 = new BitString("", 12);
// conversion to hex strings
- assertEquals(
- "",
- b0.toHexString());
- assertEquals(
- "1",
- b1.toHexString());
- assertEquals(
- "2",
- b2.toHexString());
- assertEquals(
- "4",
- b4.toHexString());
- assertEquals(
- "8",
- b8.toHexString());
- assertEquals(
- "10",
- b16.toHexString());
- assertEquals(
- "20",
- b32.toHexString());
- assertEquals(
- "40",
- b64.toHexString());
- assertEquals(
- "80",
- b128.toHexString());
- assertEquals(
- "100",
- b256.toHexString());
- assertEquals(
- "0", b0x1.toHexString());
- assertEquals(
- "000", b0x12.toHexString());
+ assertThat(b0.toHexString(), is(""));
+ assertThat(b1.toHexString(), is("1"));
+ assertThat(b2.toHexString(), is("2"));
+ assertThat(b4.toHexString(), is("4"));
+ assertThat(b8.toHexString(), is("8"));
+ assertThat(b16.toHexString(), is("10"));
+ assertThat(b32.toHexString(), is("20"));
+ assertThat(b64.toHexString(), is("40"));
+ assertThat(b128.toHexString(), is("80"));
+ assertThat(b256.toHexString(), is("100"));
+ assertThat(b0x1.toHexString(), is("0"));
+ assertThat(b0x12.toHexString(), is("000"));
// to byte array
assertByteArray("01", "1", 1);
@@ -416,7 +379,7 @@ class UtilTest {
int bitCount) {
byte[] bytes = BitString.toByteArrayFromBitString(bits, bitCount);
final String s = toString(bytes);
- assertEquals(expected, s);
+ assertThat(s, is(expected));
}
/**
@@ -444,21 +407,21 @@ class UtilTest {
numberList.add(null);
numberList.add(2);
List<Integer> integerList = Util.cast(numberList, Integer.class);
- assertEquals(3, integerList.size());
- assertEquals(Integer.valueOf(2), integerList.get(2));
+ assertThat(integerList, hasSize(3));
+ assertThat(integerList.get(2), is(Integer.valueOf(2)));
// Nulls are OK.
assertNull(integerList.get(1));
// Can update the underlying list.
integerList.set(1, 345);
- assertEquals(Integer.valueOf(345), integerList.get(1));
+ assertThat(integerList.get(1), is(Integer.valueOf(345)));
integerList.set(1, null);
assertNull(integerList.get(1));
// Can add a member of the wrong type to the underlying list.
numberList.add(3.1415D);
- assertEquals(4, integerList.size());
+ assertThat(integerList, hasSize(4));
// Access a member which is of the wrong type.
try {
@@ -517,7 +480,7 @@ class UtilTest {
final List<String> a = ConsList.of("a", ImmutableList.of());
assertThat(a, hasSize(1));
- assertThat(a, is(Collections.singletonList("a")));
+ assertThat(a, isListOf("a"));
}
@Test void testConsPerformance() {
@@ -538,11 +501,11 @@ class UtilTest {
assertThat(total, is((long) n * (n - 1) / 2));
final Object[] objects = list.toArray();
- assertThat(objects.length, is(n));
+ assertThat(objects, arrayWithSize(n));
final Integer[] integers = new Integer[n - 1];
- assertThat(integers.length, is(n - 1));
+ assertThat(integers, arrayWithSize(n - 1));
final Integer[] integers2 = list.toArray(integers);
- assertThat(integers2.length, is(n));
+ assertThat(integers2, arrayWithSize(n));
assertThat(integers2[0], is(start));
assertThat(integers2[integers2.length - 1], is(n + start - 1));
final Integer[] integers3 = list.toArray(integers2);
@@ -550,13 +513,13 @@ class UtilTest {
final Integer[] integers4 = new Integer[n + 1];
final Integer[] integers5 = list.toArray(integers4);
assertThat(integers5, sameInstance(integers4));
- assertThat(integers5.length, is(n + 1));
+ assertThat(integers5, arrayWithSize(n + 1));
assertThat(integers5[0], is(start));
assertThat(integers5[n - 1], is(n + start - 1));
assertThat(integers5[n], nullValue());
assertThat(list.hashCode(), is(Arrays.hashCode(integers3)));
- assertThat(list, is(Arrays.asList(integers3)));
+ assertThat(list, isListOf(integers3));
assertThat(list, is(list));
assertThat(Arrays.asList(integers3), is(list));
}
@@ -582,9 +545,9 @@ class UtilTest {
sb.append(entry.getKey()).append("=").append(entry.getValue());
sb.append(";");
}
- assertEquals("bar=ringo;foo=george;", sb.toString());
+ assertThat(sb, hasToString("bar=ringo;foo=george;"));
- assertEquals(2, Util.toMap(properties).entrySet().size());
+ assertThat(Util.toMap(properties).entrySet(), hasSize(2));
properties.put("nonString", 34);
try {
@@ -729,9 +692,9 @@ class UtilTest {
@Test void testEnumConstants() {
final Map<String, MemoryType> memoryTypeMap =
Util.enumConstants(MemoryType.class);
- assertEquals(2, memoryTypeMap.size());
- assertEquals(MemoryType.HEAP, memoryTypeMap.get("HEAP"));
- assertEquals(MemoryType.NON_HEAP, memoryTypeMap.get("NON_HEAP"));
+ assertThat(memoryTypeMap, aMapWithSize(2));
+ assertThat(memoryTypeMap.get("HEAP"), is(MemoryType.HEAP));
+ assertThat(memoryTypeMap.get("NON_HEAP"), is(MemoryType.NON_HEAP));
try {
memoryTypeMap.put("FOO", null);
fail("expected exception");
@@ -739,7 +702,7 @@ class UtilTest {
// expected: map is immutable
}
- assertEquals("HEAP", Util.enumVal(MemoryType.class, "HEAP").name());
+ assertThat(Util.enumVal(MemoryType.class, "HEAP").name(), is("HEAP"));
assertNull(Util.enumVal(MemoryType.class, "heap"));
assertNull(Util.enumVal(MemoryType.class, "nonexistent"));
}
@@ -749,48 +712,49 @@ class UtilTest {
*/
@Test void testSqlBuilder() {
final SqlBuilder buf = new SqlBuilder(CalciteSqlDialect.DEFAULT);
- assertEquals(0, buf.length());
+ assertThat(buf.length(), is(0));
buf.append("select ");
- assertEquals("select ", buf.getSql());
+ assertThat(buf.getSql(), is("select "));
buf.identifier("x");
- assertEquals("select \"x\"", buf.getSql());
+ assertThat(buf.getSql(), is("select \"x\""));
buf.append(", ");
buf.identifier("y", "a b");
- assertEquals("select \"x\", \"y\".\"a b\"", buf.getSql());
+ assertThat(buf.getSql(), is("select \"x\", \"y\".\"a b\""));
final SqlString sqlString = buf.toSqlString();
- assertEquals(CalciteSqlDialect.DEFAULT, sqlString.getDialect());
- assertEquals(buf.getSql(), sqlString.getSql());
+ assertThat(sqlString.getDialect(), is(CalciteSqlDialect.DEFAULT));
+ assertThat(sqlString.getSql(), is(buf.getSql()));
- assertTrue(buf.getSql().length() > 0);
- assertEquals(buf.getSqlAndClear(), sqlString.getSql());
- assertEquals(0, buf.length());
+ assertThat(buf.getSql(), not(emptyString()));
+ assertThat(sqlString.getSql(), is(buf.getSqlAndClear()));
+ assertThat(buf.length(), is(0));
buf.clear();
- assertEquals(0, buf.length());
+ assertThat(buf.length(), is(0));
buf.literal("can't get no satisfaction");
- assertEquals("'can''t get no satisfaction'", buf.getSqlAndClear());
+ assertThat(buf.getSqlAndClear(), is("'can''t get no satisfaction'"));
buf.literal(new Timestamp(0));
- assertEquals("TIMESTAMP '1970-01-01 00:00:00'", buf.getSqlAndClear());
+ assertThat(buf.getSqlAndClear(), is("TIMESTAMP '1970-01-01 00:00:00'"));
buf.literal(new Timestamp(1261053296000L));
- assertEquals("TIMESTAMP '2009-12-17 12:34:56'", buf.getSqlAndClear());
+ assertThat(buf.getSqlAndClear(), is("TIMESTAMP '2009-12-17 12:34:56'"));
buf.append("select ");
buf.literal(new Timestamp(1261053296000L));
- assertEquals("select TIMESTAMP '2009-12-17 12:34:56'", buf.getSqlAndClear());
+ assertThat(buf.getSqlAndClear(),
+ is("select TIMESTAMP '2009-12-17 12:34:56'"));
buf.clear();
- assertEquals(0, buf.length());
+ assertThat(buf.length(), is(0));
buf.append("hello world");
- assertEquals(2, buf.indexOf("l"));
- assertEquals(-1, buf.indexOf("z"));
- assertEquals(9, buf.indexOf("l", 5));
+ assertThat(buf.indexOf("l"), is(2));
+ assertThat(buf.indexOf("z"), is(-1));
+ assertThat(buf.indexOf("l", 5), is(9));
}
/**
@@ -800,7 +764,7 @@ class UtilTest {
// Made up of zero lists
//noinspection unchecked
List<String> list = CompositeList.of(new List[0]);
- assertEquals(0, list.size());
+ assertThat(list, hasSize(0));
assertTrue(list.isEmpty());
try {
final String s = list.get(0);
@@ -816,10 +780,10 @@ class UtilTest {
// Made up of three lists, two of which are empty
list = CompositeList.of(listEmpty, listAbc, listEmpty2);
- assertEquals(3, list.size());
+ assertThat(list, hasSize(3));
assertFalse(list.isEmpty());
- assertEquals("a", list.get(0));
- assertEquals("c", list.get(2));
+ assertThat(list.get(0), is("a"));
+ assertThat(list.get(2), is("c"));
try {
final String s = list.get(3);
fail("expected error, got " + s);
@@ -836,8 +800,8 @@ class UtilTest {
// Iterator
final Iterator<String> iterator = list.iterator();
assertTrue(iterator.hasNext());
- assertEquals("a", iterator.next());
- assertEquals("b", iterator.next());
+ assertThat(iterator.next(), is("a"));
+ assertThat(iterator.next(), is("b"));
assertTrue(iterator.hasNext());
try {
iterator.remove();
@@ -845,20 +809,20 @@ class UtilTest {
} catch (UnsupportedOperationException e) {
// ok
}
- assertEquals("c", iterator.next());
+ assertThat(iterator.next(), is("c"));
assertFalse(iterator.hasNext());
// Extend one of the backing lists, and list grows.
listEmpty2.add("zz");
- assertEquals(4, list.size());
- assertEquals("zz", list.get(3));
+ assertThat(list, hasSize(4));
+ assertThat(list.get(3), is("zz"));
// Syntactic sugar 'of' method
String ss = "";
for (String s : CompositeList.of(list, list)) {
ss += s;
}
- assertEquals("abczzabczz", ss);
+ assertThat(ss, is("abczzabczz"));
}
/**
@@ -875,10 +839,9 @@ class UtilTest {
final HashMap<Object, Object> map = new HashMap<>();
map.put("person", "world");
map.put("time", "day");
- assertEquals(
- "Hello, world, what a nice day.",
- Template.formatByName(
- "Hello, {person}, what a nice {time}.", map));
+ assertThat(
+ Template.formatByName("Hello, {person}, what a nice {time}.", map),
+ is("Hello, world, what a nice day."));
// String and an integer.
final Template template =
@@ -886,46 +849,36 @@ class UtilTest {
map.clear();
map.put("person", "Ringo");
map.put("age", 64.5);
- assertEquals(
- "Happy 64.50th birthday, Ringo!", template.format(map));
+ assertThat(template.format(map), is("Happy 64.50th birthday, Ringo!"));
// Missing parameters evaluate to null.
map.remove("person");
- assertEquals(
- "Happy 64.50th birthday, null!",
- template.format(map));
+ assertThat(template.format(map), is("Happy 64.50th birthday, null!"));
// Specify parameter by Integer ordinal.
map.clear();
map.put(1, "Ringo");
map.put("0", 64.5);
- assertEquals(
- "Happy 64.50th birthday, Ringo!",
- template.format(map));
+ assertThat(template.format(map), is("Happy 64.50th birthday, Ringo!"));
// Too many parameters supplied.
map.put("lastName", "Starr");
map.put("homeTown", "Liverpool");
- assertEquals(
- "Happy 64.50th birthday, Ringo!",
- template.format(map));
+ assertThat(template.format(map), is("Happy 64.50th birthday, Ringo!"));
// Get parameter names. In order of appearance.
- assertEquals(
- Arrays.asList("age", "person"),
- template.getParameterNames());
+ assertThat(template.getParameterNames(),
+ isListOf("age", "person"));
// No parameters; doubled single quotes; quoted braces.
final Template template2 =
Template.of("Don''t expand 'this {brace}'.");
- assertEquals(
- Collections.<String>emptyList(), template2.getParameterNames());
- assertEquals(
- "Don't expand this {brace}.",
- template2.format(Collections.emptyMap()));
+ assertThat(template2.getParameterNames(), empty());
+ assertThat(template2.format(Collections.emptyMap()),
+ is("Don't expand this {brace}."));
// Empty template.
- assertEquals("", Template.formatByName("", map));
+ assertThat(Template.formatByName("", map), is(""));
}
/**
@@ -941,14 +894,14 @@ class UtilTest {
Locale.ROOT,
};
for (Locale locale : locales) {
- assertEquals(locale, Util.parseLocale(locale.toString()));
+ assertThat(Util.parseLocale(locale.toString()), is(locale));
}
// Example locale names in Locale.toString() javadoc.
String[] localeNames = {
"en", "de_DE", "gb_GB", "en_US_WINDOWS", "de__POSIX", "fr__MACOS"
};
for (String localeName : localeNames) {
- assertEquals(localeName, Util.parseLocale(localeName).toString());
+ assertThat(Util.parseLocale(localeName), hasToString(localeName));
}
}
@@ -1008,12 +961,12 @@ class UtilTest {
}
@Test void testSpaces() {
- assertEquals("", Spaces.of(0));
- assertEquals(" ", Spaces.of(1));
- assertEquals(" ", Spaces.of(1));
- assertEquals(" ", Spaces.of(9));
- assertEquals(" ", Spaces.of(5));
- assertEquals(1000, Spaces.of(1000).length());
+ assertThat(Spaces.of(0), is(""));
+ assertThat(Spaces.of(1), is(" "));
+ assertThat(Spaces.of(1), is(" "));
+ assertThat(Spaces.of(9), is(" "));
+ assertThat(Spaces.of(5), is(" "));
+ assertThat(Spaces.of(1000).length(), is(1000));
}
@Test void testSpaceString() {
@@ -1054,14 +1007,14 @@ class UtilTest {
List<String> strings = Arrays.asList("paul", "george", "john", "ringo");
List<Integer> integers = Arrays.asList(1942, 1943, 1940);
List<Pair<String, Integer>> zip = Pair.zip(strings, integers);
- assertEquals(3, zip.size());
- assertEquals("paul:1942", zip.get(0).left + ":" + zip.get(0).right);
- assertEquals("john", zip.get(2).left);
+ assertThat(zip, hasSize(3));
+ assertThat(zip.get(0).left + ":" + zip.get(0).right, is("paul:1942"));
+ assertThat(zip.get(2).left, is("john"));
int x = 0;
for (Pair<String, Integer> pair : zip) {
x += pair.right;
}
- assertEquals(5825, x);
+ assertThat(x, is(5825));
}
/**
@@ -1207,33 +1160,33 @@ class UtilTest {
*/
@Test void testQuotientList() {
List<String> beatles = Arrays.asList("john", "paul", "george", "ringo");
- final List list0 = Util.quotientList(beatles, 3, 0);
- assertEquals(2, list0.size());
- assertEquals("john", list0.get(0));
- assertEquals("ringo", list0.get(1));
+ final List<String> list0 = Util.quotientList(beatles, 3, 0);
+ assertThat(list0, hasSize(2));
+ assertThat(list0.get(0), is("john"));
+ assertThat(list0.get(1), is("ringo"));
- final List list1 = Util.quotientList(beatles, 3, 1);
- assertEquals(1, list1.size());
- assertEquals("paul", list1.get(0));
+ final List<String> list1 = Util.quotientList(beatles, 3, 1);
+ assertThat(list1, hasSize(1));
+ assertThat(list1.get(0), is("paul"));
- final List list2 = Util.quotientList(beatles, 3, 2);
- assertEquals(1, list2.size());
- assertEquals("george", list2.get(0));
+ final List<String> list2 = Util.quotientList(beatles, 3, 2);
+ assertThat(list2, hasSize(1));
+ assertThat(list2.get(0), is("george"));
try {
- final List listBad = Util.quotientList(beatles, 3, 4);
+ final List<String> listBad = Util.quotientList(beatles, 3, 4);
fail("Expected error, got " + listBad);
} catch (IllegalArgumentException e) {
// ok
}
try {
- final List listBad = Util.quotientList(beatles, 3, 3);
+ final List<String> listBad = Util.quotientList(beatles, 3, 3);
fail("Expected error, got " + listBad);
} catch (IllegalArgumentException e) {
// ok
}
try {
- final List listBad = Util.quotientList(beatles, 0, 0);
+ final List<String> listBad = Util.quotientList(beatles, 0, 0);
fail("Expected error, got " + listBad);
} catch (IllegalArgumentException e) {
// ok
@@ -1242,15 +1195,15 @@ class UtilTest {
// empty
final List<String> empty = Collections.emptyList();
final List<String> list3 = Util.quotientList(empty, 7, 2);
- assertEquals(0, list3.size());
+ assertThat(list3, hasSize(0));
// shorter than n
- final List list4 = Util.quotientList(beatles, 10, 0);
- assertEquals(1, list4.size());
- assertEquals("john", list4.get(0));
+ final List<String> list4 = Util.quotientList(beatles, 10, 0);
+ assertThat(list4, hasSize(1));
+ assertThat(list4.get(0), is("john"));
- final List list5 = Util.quotientList(beatles, 10, 5);
- assertEquals(0, list5.size());
+ final List<String> list5 = Util.quotientList(beatles, 10, 5);
+ assertThat(list5, hasSize(0));
final List<Pair<String, String>> list6 = Util.pairs(beatles);
assertThat(list6, hasSize(2));
@@ -1267,7 +1220,7 @@ class UtilTest {
final BiConsumer<ImmutableIntList, List<Integer>> c2 = (intList, list) -> {
assertThat(list, hasSize(intList.size()));
assertThat(list, is(intList));
- assertThat(list.toString(), is(intList.toString()));
+ assertThat(list, hasToString(intList.toString()));
assertThat(list.hashCode(), is(intList.hashCode()));
};
@@ -1291,20 +1244,20 @@ class UtilTest {
};
final ImmutableIntList list = ImmutableIntList.of();
- assertEquals(0, list.size());
- assertEquals(list, Collections.<Integer>emptyList());
+ assertThat(list, hasSize(0));
+ assertThat(Collections.<Integer>emptyList(), is(list));
assertThat(list, hasToString("[]"));
assertThat(BitSets.of(list), equalTo(new BitSet()));
final ImmutableIntList list2 = ImmutableIntList.of(1, 3, 5);
- assertEquals(3, list2.size());
- assertEquals("[1, 3, 5]", list2.toString());
- assertEquals(list2.hashCode(), Arrays.asList(1, 3, 5).hashCode());
+ assertThat(list2, hasSize(3));
+ assertThat(list2, hasToString("[1, 3, 5]"));
+ assertThat(Arrays.asList(1, 3, 5).hashCode(), is(list2.hashCode()));
Integer[] integers = list2.toArray(new Integer[3]);
- assertEquals(1, (int) integers[0]);
- assertEquals(3, (int) integers[1]);
- assertEquals(5, (int) integers[2]);
+ assertThat((int) integers[0], is(1));
+ assertThat((int) integers[1], is(3));
+ assertThat((int) integers[2], is(5));
//noinspection EqualsWithItself
assertThat(list.equals(list), is(true));
@@ -1316,7 +1269,7 @@ class UtilTest {
assertThat(list2.appendAll(Collections.emptyList()), sameInstance(list2));
assertThat(list2.appendAll(list), sameInstance(list2));
//noinspection CollectionAddedToSelf
- assertThat(list2.appendAll(list2), is(Arrays.asList(1, 3, 5, 1, 3, 5)));
+ assertThat(list2.appendAll(list2), isListOf(1, 3, 5, 1, 3, 5));
assertThat(
Arrays.toString(ImmutableIntList.of(1).toArray(new Integer[]{5, 6, 7})),
is("[1, null, 7]"));
@@ -1331,9 +1284,9 @@ class UtilTest {
final IdPair<Integer, Integer> p0OneTwo = IdPair.of(1, 2);
final IdPair<Integer, Integer> p1OneTwo = IdPair.of(1, 2);
final IdPair<Integer, Integer> p1TwoOne = IdPair.of(2, 1);
- assertEquals(p0OneTwo, p0OneTwo);
- assertEquals(p0OneTwo, p1OneTwo);
- assertEquals(p0OneTwo.hashCode(), p1OneTwo.hashCode());
+ assertThat(p0OneTwo, is(p0OneTwo));
+ assertThat(p1OneTwo, is(p0OneTwo));
+ assertThat(p1OneTwo.hashCode(), is(p0OneTwo.hashCode()));
assertNotEquals(p0OneTwo, p1TwoOne);
final String s0 = "xy";
@@ -1343,20 +1296,20 @@ class UtilTest {
final IdPair<String, Integer> p0s0One = IdPair.of(s0, 1);
final IdPair<String, Integer> p1s0One = IdPair.of(s0, 1);
assertNotSame(p0s0One, p1s0One); // different objects, but are equal
- assertEquals(p0s0One, p0s0One);
- assertEquals(p0s0One, p1s0One);
- assertEquals(p1s0One, p0s0One);
- assertEquals(p0s0One.hashCode(), p1s0One.hashCode());
+ assertThat(p0s0One, is(p0s0One));
+ assertThat(p1s0One, is(p0s0One));
+ assertThat(p0s0One, is(p1s0One));
+ assertThat(p1s0One.hashCode(), is(p0s0One.hashCode()));
// A copy of "s0" that is equal but not the same object
final String s1 = s0.toUpperCase(Locale.ROOT).toLowerCase(Locale.ROOT);
- assertEquals(s0, s1);
+ assertThat(s1, is(s0));
assertNotSame(s0, s1);
// p0s1One is not equal to p0s0One because s1 is not the same object as s0
final IdPair<String, Integer> p0s1One = IdPair.of(s1, 1);
assertNotEquals(p0s0One, p0s1One);
- assertEquals(p0s1One.hashCode(), p0s1One.hashCode());
+ assertThat(p0s1One.hashCode(), is(p0s1One.hashCode()));
final Set<IdPair<?, ?>> set =
ImmutableSet.of(p0OneTwo, p1OneTwo, p1TwoOne,
@@ -1386,15 +1339,28 @@ class UtilTest {
checkIntegerIntervalSet("1,3,1,2-4,-2,-4", 1, 3);
}
- private List<Integer> checkIntegerIntervalSet(String s, int... ints) {
- List<Integer> list = new ArrayList<>();
+ @SuppressWarnings({"UseBulkOperation",
+ "CollectionAddAllCanBeReplacedWithConstructor"})
+ private void checkIntegerIntervalSet(String s, int... ints) {
+ final List<Integer> intList = Ints.asList(ints);
+ final Set<Integer> intSet = new LinkedHashSet<>(intList);
+
final Set<Integer> set = IntegerIntervalSet.of(s);
- assertEquals(set.size(), ints.length);
- for (Integer integer : set) {
- list.add(integer);
+ assertThat(set, hasSize(ints.length));
+ assertThat(set, is(intSet));
+
+ List<Integer> list = new ArrayList<>(set);
+ assertThat(list, is(intList));
+
+ List<Integer> list2 = new ArrayList<>();
+ for (Integer i : set) {
+ list2.add(i);
}
- assertEquals(new HashSet<>(Ints.asList(ints)), set);
- return list;
+ assertThat(list2, is(intList));
+
+ List<Integer> list3 = new ArrayList<>();
+ list3.addAll(intSet);
+ assertThat(list3, is(intList));
}
/**
@@ -1404,39 +1370,39 @@ class UtilTest {
@Test void testFlatList() {
final List<String> emp = FlatLists.of();
final List<String> emp0 = Collections.emptyList();
- assertEquals(emp, emp0);
- assertEquals(emp.hashCode(), emp0.hashCode());
+ assertThat(emp0, is(emp));
+ assertThat(emp0.hashCode(), is(emp.hashCode()));
final List<String> ab = FlatLists.of("A", "B");
final List<String> ab0 = Arrays.asList("A", "B");
- assertEquals(ab, ab0);
- assertEquals(ab.hashCode(), ab0.hashCode());
+ assertThat(ab0, is(ab));
+ assertThat(ab0.hashCode(), is(ab.hashCode()));
final List<String> abc = FlatLists.of("A", "B", "C");
final List<String> abc0 = Arrays.asList("A", "B", "C");
- assertEquals(abc, abc0);
- assertEquals(abc.hashCode(), abc0.hashCode());
+ assertThat(abc0, is(abc));
+ assertThat(abc0.hashCode(), is(abc.hashCode()));
final List<Object> abc1 = FlatLists.of((Object) "A", "B", "C");
- assertEquals(abc1, abc0);
- assertEquals(abc, abc0);
- assertEquals(abc1.hashCode(), abc0.hashCode());
+ assertThat(abc0, is(abc1));
+ assertThat(abc0, is(abc));
+ assertThat(abc0.hashCode(), is(abc1.hashCode()));
final List<String> an = FlatLists.of("A", null);
final List<String> an0 = Arrays.asList("A", null);
- assertEquals(an, an0);
- assertEquals(an.hashCode(), an0.hashCode());
+ assertThat(an0, is(an));
+ assertThat(an0.hashCode(), is(an.hashCode()));
final List<String> anb = FlatLists.of("A", null, "B");
final List<String> anb0 = Arrays.asList("A", null, "B");
- assertEquals(anb, anb0);
- assertEquals(anb.hashCode(), anb0.hashCode());
- assertEquals(1, anb.indexOf(null), anb + ".indexOf(null)");
- assertEquals(1, anb.lastIndexOf(null), anb + ".lastIndexOf(null)");
- assertEquals(2, anb.indexOf("B"), anb + ".indexOf(B)");
- assertEquals(0, anb.lastIndexOf("A"), anb + ".lastIndexOf(A)");
- assertEquals(-1, anb.indexOf("Z"), anb + ".indexOf(Z)");
- assertEquals(-1, anb.lastIndexOf("Z"), anb + ".lastIndexOf(Z)");
+ assertThat(anb0, is(anb));
+ assertThat(anb0.hashCode(), is(anb.hashCode()));
+ assertThat(anb + ".indexOf(null)", anb.indexOf(null), is(1));
+ assertThat(anb + ".lastIndexOf(null)", anb.lastIndexOf(null), is(1));
+ assertThat(anb + ".indexOf(B)", anb.indexOf("B"), is(2));
+ assertThat(anb + ".lastIndexOf(A)", anb.lastIndexOf("A"), is(0));
+ assertThat(anb + ".indexOf(Z)", anb.indexOf("Z"), is(-1));
+ assertThat(anb + ".lastIndexOf(Z)", anb.lastIndexOf("Z"), is(-1));
// Comparisons
assertThat(emp, instanceOf(Comparable.class));
@@ -1515,12 +1481,12 @@ class UtilTest {
Arrays.asList("A", "B", "C", "D", "E", "F", "G").subList(0, n);
final List<String> eNull0 =
Arrays.asList("A", null, "C", "D", "E", "F", "G").subList(0, n);
- assertEquals(emp, emp0);
- assertEquals(emp, emp1);
- assertEquals(emp0, emp1);
- assertEquals(emp1, emp0);
- assertEquals(emp.hashCode(), emp0.hashCode());
- assertEquals(emp.hashCode(), emp1.hashCode());
+ assertThat(emp0, is(emp));
+ assertThat(emp1, is(emp));
+ assertThat(emp1, is(emp0));
+ assertThat(emp0, is(emp1));
+ assertThat(emp0.hashCode(), is(emp.hashCode()));
+ assertThat(emp1.hashCode(), is(emp.hashCode()));
assertThat(emp, hasSize(n));
if (eNull != null) {
@@ -1529,12 +1495,12 @@ class UtilTest {
final List<String> an = FlatLists.of("A", null);
final List<String> an0 = Arrays.asList("A", null);
- assertEquals(an, an0);
- assertEquals(an.hashCode(), an0.hashCode());
+ assertThat(an0, is(an));
+ assertThat(an0.hashCode(), is(an.hashCode()));
if (eNull != null) {
- assertEquals(eNull, eNull0);
- assertEquals(eNull.hashCode(), eNull0.hashCode());
+ assertThat(eNull0, is(eNull));
+ assertThat(eNull0.hashCode(), is(eNull.hashCode()));
}
assertThat(emp, hasToString(emp1.toString()));
@@ -1653,23 +1619,22 @@ class UtilTest {
* Unit test for {@link AvaticaUtils#toCamelCase(String)}.
*/
@Test void testToCamelCase() {
- assertEquals("myJdbcDriver", AvaticaUtils.toCamelCase("MY_JDBC_DRIVER"));
- assertEquals("myJdbcDriver", AvaticaUtils.toCamelCase("MY_JDBC__DRIVER"));
- assertEquals("myJdbcDriver", AvaticaUtils.toCamelCase("my_jdbc_driver"));
- assertEquals("abCdefGHij", AvaticaUtils.toCamelCase("ab_cdEf_g_Hij"));
- assertEquals("JdbcDriver", AvaticaUtils.toCamelCase("_JDBC_DRIVER"));
- assertEquals("", AvaticaUtils.toCamelCase("_"));
- assertEquals("", AvaticaUtils.toCamelCase(""));
+ assertThat(AvaticaUtils.toCamelCase("MY_JDBC_DRIVER"), is("myJdbcDriver"));
+ assertThat(AvaticaUtils.toCamelCase("a_JDBC__DRIVER"), is("aJdbcDriver"));
+ assertThat(AvaticaUtils.toCamelCase("my_jdbc_driver"), is("myJdbcDriver"));
+ assertThat(AvaticaUtils.toCamelCase("ab_cdEf_g_Hij"), is("abCdefGHij"));
+ assertThat(AvaticaUtils.toCamelCase("_JDBC_DRIVER"), is("JdbcDriver"));
+ assertThat(AvaticaUtils.toCamelCase("_"), is(""));
+ assertThat(AvaticaUtils.toCamelCase(""), is(""));
}
/** Unit test for {@link AvaticaUtils#camelToUpper(String)}. */
@Test void testCamelToUpper() {
- assertEquals("MY_JDBC_DRIVER", AvaticaUtils.camelToUpper("myJdbcDriver"));
- assertEquals("MY_J_D_B_C_DRIVER",
- AvaticaUtils.camelToUpper("myJDBCDriver"));
- assertEquals("AB_CDEF_G_HIJ", AvaticaUtils.camelToUpper("abCdefGHij"));
- assertEquals("_JDBC_DRIVER", AvaticaUtils.camelToUpper("JdbcDriver"));
- assertEquals("", AvaticaUtils.camelToUpper(""));
+ assertThat(AvaticaUtils.camelToUpper("myJdbcDriver"), is("MY_JDBC_DRIVER"));
+ assertThat(AvaticaUtils.camelToUpper("myJDBCDriver"), is("MY_J_D_B_C_DRIVER"));
+ assertThat(AvaticaUtils.camelToUpper("abCdefGHij"), is("AB_CDEF_G_HIJ"));
+ assertThat(AvaticaUtils.camelToUpper("JdbcDriver"), is("_JDBC_DRIVER"));
+ assertThat(AvaticaUtils.camelToUpper(""), is(""));
}
/**
@@ -1789,11 +1754,10 @@ class UtilTest {
}
private void checkCompositeMap(String[] beatles, Map<String, Integer> map) {
- assertThat(4, equalTo(map.size()));
- assertThat(false, equalTo(map.isEmpty()));
- assertThat(
- map.keySet(),
- equalTo((Set<String>) new HashSet<String>(Arrays.asList(beatles))));
+ assertThat(map, aMapWithSize(4));
+ assertThat(map.isEmpty(), is(false));
+ assertThat(map.keySet(),
+ equalTo(new HashSet<>(Arrays.asList(beatles))));
assertThat(
ImmutableMultiset.copyOf(map.values()),
equalTo(ImmutableMultiset.copyOf(Arrays.asList(4, 4, 6, 5))));
@@ -1865,9 +1829,9 @@ class UtilTest {
/** Unit test for {@link Util#distinctList(List)}
* and {@link Util#distinctList(Iterable)}. */
@Test void testDistinctList() {
- assertThat(Util.distinctList(Arrays.asList(1, 2)), is(Arrays.asList(1, 2)));
+ assertThat(Util.distinctList(Arrays.asList(1, 2)), isListOf(1, 2));
assertThat(Util.distinctList(Arrays.asList(1, 2, 1)),
- is(Arrays.asList(1, 2)));
+ isListOf(1, 2));
try {
List<Object> o = Util.distinctList(null);
fail("expected exception, got " + o);
@@ -1885,10 +1849,10 @@ class UtilTest {
assertThat(Util.distinctList(a), sameInstance(a));
final List<String> cbca = ImmutableList.of("c", "b", "c", "a");
assertThat(Util.distinctList(cbca), not(sameInstance(cbca)));
- assertThat(Util.distinctList(cbca), is(Arrays.asList("c", "b", "a")));
+ assertThat(Util.distinctList(cbca), isListOf("c", "b", "a"));
final Collection<String> cbcaC = new LinkedHashSet<>(cbca);
assertThat(Util.distinctList(cbcaC), not(sameInstance(cbca)));
- assertThat(Util.distinctList(cbcaC), is(Arrays.asList("c", "b", "a")));
+ assertThat(Util.distinctList(cbcaC), isListOf("c", "b", "a"));
final List<String> a2 = ImmutableList.of("a", "a");
assertThat(Util.distinctList(a2), is(a));
// Short list that is not distinct
@@ -3073,10 +3037,10 @@ class UtilTest {
Arrays.asList("John", "Paul", "George", "Ringo");
final List<String> empty = Collections.emptyList();
assertThat(Util.transform(beatles, s -> s.toUpperCase(Locale.ROOT)),
- is(Arrays.asList("JOHN", "PAUL", "GEORGE", "RINGO")));
+ isListOf("JOHN", "PAUL", "GEORGE", "RINGO"));
assertThat(Util.transform(empty, s -> s.toUpperCase(Locale.ROOT)), is(empty));
assertThat(Util.transform(beatles, String::length),
- is(Arrays.asList(4, 4, 6, 5)));
+ isListOf(4, 4, 6, 5));
assertThat(Util.transform(beatles, String::length),
instanceOf(RandomAccess.class));
final List<String> beatles2 = new LinkedList<>(beatles);
@@ -3084,10 +3048,10 @@ class UtilTest {
not(instanceOf(RandomAccess.class)));
assertThat(Util.transformIndexed(beatles, (s, i) -> i + ": " + s),
- allOf(is(Arrays.asList("0: John", "1: Paul", "2: George", "3: Ringo")),
+ allOf(isListOf("0: John", "1: Paul", "2: George", "3: Ringo"),
instanceOf(RandomAccess.class)));
assertThat(Util.transformIndexed(beatles2, (s, i) -> i + ": " + s),
- allOf(is(Arrays.asList("0: John", "1: Paul", "2: George", "3: Ringo")),
+ allOf(isListOf("0: John", "1: Paul", "2: George", "3: Ringo"),
not(instanceOf(RandomAccess.class))));
}
diff --git a/core/src/test/java/org/apache/calcite/util/format/postgresql/PostgresqlDateTimeFormatterTest.java b/core/src/test/java/org/apache/calcite/util/format/postgresql/PostgresqlDateTimeFormatterTest.java
index 7745625005..6db1fd9391 100644
--- a/core/src/test/java/org/apache/calcite/util/format/postgresql/PostgresqlDateTimeFormatterTest.java
+++ b/core/src/test/java/org/apache/calcite/util/format/postgresql/PostgresqlDateTimeFormatterTest.java
@@ -26,7 +26,8 @@ import java.time.ZonedDateTime;
import java.time.temporal.ChronoField;
import java.util.Locale;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.fail;
/**
@@ -69,28 +70,28 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime noon = createDateTime(2024, 1, 1, 12, 0, 0, 0);
final ZonedDateTime evening = createDateTime(2024, 1, 1, 18, 0, 0, 0);
- assertEquals("12", toCharUs(pattern, midnight));
- assertEquals("06", toCharUs(pattern, morning));
- assertEquals("12", toCharUs(pattern, noon));
- assertEquals("06", toCharUs(pattern, evening));
- assertEquals("12", toCharUs("FM" + pattern, midnight));
- assertEquals("6", toCharUs("FM" + pattern, morning));
- assertEquals("12", toCharUs("FM" + pattern, noon));
- assertEquals("6", toCharUs("FM" + pattern, evening));
+ assertThat(toCharUs(pattern, midnight), is("12"));
+ assertThat(toCharUs(pattern, morning), is("06"));
+ assertThat(toCharUs(pattern, noon), is("12"));
+ assertThat(toCharUs(pattern, evening), is("06"));
+ assertThat(toCharUs("FM" + pattern, midnight), is("12"));
+ assertThat(toCharUs("FM" + pattern, morning), is("6"));
+ assertThat(toCharUs("FM" + pattern, noon), is("12"));
+ assertThat(toCharUs("FM" + pattern, evening), is("6"));
final ZonedDateTime hourOne = createDateTime(2024, 1, 1, 1, 0, 0, 0);
final ZonedDateTime hourTwo = createDateTime(2024, 1, 1, 2, 0, 0, 0);
final ZonedDateTime hourThree = createDateTime(2024, 1, 1, 3, 0, 0, 0);
- assertEquals("12TH", toCharUs(pattern + "TH", midnight));
- assertEquals("01ST", toCharUs(pattern + "TH", hourOne));
- assertEquals("02ND", toCharUs(pattern + "TH", hourTwo));
- assertEquals("03RD", toCharUs(pattern + "TH", hourThree));
- assertEquals("12th", toCharUs(pattern + "th", midnight));
- assertEquals("01st", toCharUs(pattern + "th", hourOne));
- assertEquals("02nd", toCharUs(pattern + "th", hourTwo));
- assertEquals("03rd", toCharUs(pattern + "th", hourThree));
+ assertThat(toCharUs(pattern + "TH", midnight), is("12TH"));
+ assertThat(toCharUs(pattern + "TH", hourOne), is("01ST"));
+ assertThat(toCharUs(pattern + "TH", hourTwo), is("02ND"));
+ assertThat(toCharUs(pattern + "TH", hourThree), is("03RD"));
+ assertThat(toCharUs(pattern + "th", midnight), is("12th"));
+ assertThat(toCharUs(pattern + "th", hourOne), is("01st"));
+ assertThat(toCharUs(pattern + "th", hourTwo), is("02nd"));
+ assertThat(toCharUs(pattern + "th", hourThree), is("03rd"));
- assertEquals("2nd", toCharUs("FM" + pattern + "th", hourTwo));
+ assertThat(toCharUs("FM" + pattern + "th", hourTwo), is("2nd"));
}
@Test void testHH24() {
@@ -99,28 +100,28 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime noon = createDateTime(2024, 1, 1, 12, 0, 0, 0);
final ZonedDateTime evening = createDateTime(2024, 1, 1, 18, 0, 0, 0);
- assertEquals("00", toCharUs("HH24", midnight));
- assertEquals("06", toCharUs("HH24", morning));
- assertEquals("12", toCharUs("HH24", noon));
- assertEquals("18", toCharUs("HH24", evening));
- assertEquals("0", toCharUs("FMHH24", midnight));
- assertEquals("6", toCharUs("FMHH24", morning));
- assertEquals("12", toCharUs("FMHH24", noon));
- assertEquals("18", toCharUs("FMHH24", evening));
+ assertThat(toCharUs("HH24", midnight), is("00"));
+ assertThat(toCharUs("HH24", morning), is("06"));
+ assertThat(toCharUs("HH24", noon), is("12"));
+ assertThat(toCharUs("HH24", evening), is("18"));
+ assertThat(toCharUs("FMHH24", midnight), is("0"));
+ assertThat(toCharUs("FMHH24", morning), is("6"));
+ assertThat(toCharUs("FMHH24", noon), is("12"));
+ assertThat(toCharUs("FMHH24", evening), is("18"));
final ZonedDateTime hourOne = createDateTime(2024, 1, 1, 1, 0, 0, 0);
final ZonedDateTime hourTwo = createDateTime(2024, 1, 1, 2, 0, 0, 0);
final ZonedDateTime hourThree = createDateTime(2024, 1, 1, 3, 0, 0, 0);
- assertEquals("00TH", toCharUs("HH24TH", midnight));
- assertEquals("01ST", toCharUs("HH24TH", hourOne));
- assertEquals("02ND", toCharUs("HH24TH", hourTwo));
- assertEquals("03RD", toCharUs("HH24TH", hourThree));
- assertEquals("00th", toCharUs("HH24th", midnight));
- assertEquals("01st", toCharUs("HH24th", hourOne));
- assertEquals("02nd", toCharUs("HH24th", hourTwo));
- assertEquals("03rd", toCharUs("HH24th", hourThree));
+ assertThat(toCharUs("HH24TH", midnight), is("00TH"));
+ assertThat(toCharUs("HH24TH", hourOne), is("01ST"));
+ assertThat(toCharUs("HH24TH", hourTwo), is("02ND"));
+ assertThat(toCharUs("HH24TH", hourThree), is("03RD"));
+ assertThat(toCharUs("HH24th", midnight), is("00th"));
+ assertThat(toCharUs("HH24th", hourOne), is("01st"));
+ assertThat(toCharUs("HH24th", hourTwo), is("02nd"));
+ assertThat(toCharUs("HH24th", hourThree), is("03rd"));
- assertEquals("2nd", toCharUs("FMHH24th", hourTwo));
+ assertThat(toCharUs("FMHH24th", hourTwo), is("2nd"));
}
@Test void testMI() {
@@ -128,23 +129,23 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime minute2 = createDateTime(2024, 1, 1, 0, 2, 0, 0);
final ZonedDateTime minute15 = createDateTime(2024, 1, 1, 0, 15, 0, 0);
- assertEquals("00", toCharUs("MI", minute0));
- assertEquals("02", toCharUs("MI", minute2));
- assertEquals("15", toCharUs("MI", minute15));
+ assertThat(toCharUs("MI", minute0), is("00"));
+ assertThat(toCharUs("MI", minute2), is("02"));
+ assertThat(toCharUs("MI", minute15), is("15"));
- assertEquals("0", toCharUs("FMMI", minute0));
- assertEquals("2", toCharUs("FMMI", minute2));
- assertEquals("15", toCharUs("FMMI", minute15));
+ assertThat(toCharUs("FMMI", minute0), is("0"));
+ assertThat(toCharUs("FMMI", minute2), is("2"));
+ assertThat(toCharUs("FMMI", minute15), is("15"));
- assertEquals("00TH", toCharUs("MITH", minute0));
- assertEquals("02ND", toCharUs("MITH", minute2));
- assertEquals("15TH", toCharUs("MITH", minute15));
- assertEquals("00th", toCharUs("MIth", minute0));
- assertEquals("02nd", toCharUs("MIth", minute2));
- assertEquals("15th", toCharUs("MIth", minute15));
+ assertThat(toCharUs("MITH", minute0), is("00TH"));
+ assertThat(toCharUs("MITH", minute2), is("02ND"));
+ assertThat(toCharUs("MITH", minute15), is("15TH"));
+ assertThat(toCharUs("MIth", minute0), is("00th"));
+ assertThat(toCharUs("MIth", minute2), is("02nd"));
+ assertThat(toCharUs("MIth", minute15), is("15th"));
- assertEquals("2nd", toCharUs("FMMIth", minute2));
- assertEquals("2nd", toCharUs("FMMInd", minute2));
+ assertThat(toCharUs("FMMIth", minute2), is("2nd"));
+ assertThat(toCharUs("FMMInd", minute2), is("2nd"));
}
@ParameterizedTest
@@ -154,23 +155,23 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime second1001 = createDateTime(2024, 1, 1, 0, 16, 41, 0);
final ZonedDateTime endOfDay = createDateTime(2024, 1, 1, 23, 59, 59, 0);
- assertEquals("0", toCharUs(pattern, second0));
- assertEquals("1001", toCharUs(pattern, second1001));
- assertEquals("86399", toCharUs(pattern, endOfDay));
+ assertThat(toCharUs(pattern, second0), is("0"));
+ assertThat(toCharUs(pattern, second1001), is("1001"));
+ assertThat(toCharUs(pattern, endOfDay), is("86399"));
- assertEquals("0", toCharUs("FM" + pattern, second0));
- assertEquals("1001", toCharUs("FM" + pattern, second1001));
- assertEquals("86399", toCharUs("FM" + pattern, endOfDay));
+ assertThat(toCharUs("FM" + pattern, second0), is("0"));
+ assertThat(toCharUs("FM" + pattern, second1001), is("1001"));
+ assertThat(toCharUs("FM" + pattern, endOfDay), is("86399"));
- assertEquals("0TH", toCharUs(pattern + "TH", second0));
- assertEquals("1001ST", toCharUs(pattern + "TH", second1001));
- assertEquals("86399TH", toCharUs(pattern + "TH", endOfDay));
- assertEquals("0th", toCharUs(pattern + "th", second0));
- assertEquals("1001st", toCharUs(pattern + "th", second1001));
- assertEquals("86399th", toCharUs(pattern + "th", endOfDay));
+ assertThat(toCharUs(pattern + "TH", second0), is("0TH"));
+ assertThat(toCharUs(pattern + "TH", second1001), is("1001ST"));
+ assertThat(toCharUs(pattern + "TH", endOfDay), is("86399TH"));
+ assertThat(toCharUs(pattern + "th", second0), is("0th"));
+ assertThat(toCharUs(pattern + "th", second1001), is("1001st"));
+ assertThat(toCharUs(pattern + "th", endOfDay), is("86399th"));
- assertEquals("1001st", toCharUs("FM" + pattern + "th", second1001));
- assertEquals("1001nd", toCharUs("FM" + pattern + "nd", second1001));
+ assertThat(toCharUs("FM" + pattern + "th", second1001), is("1001st"));
+ assertThat(toCharUs("FM" + pattern + "nd", second1001), is("1001nd"));
}
@Test void testSS() {
@@ -178,23 +179,23 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime second2 = createDateTime(2024, 1, 1, 0, 0, 2, 0);
final ZonedDateTime second15 = createDateTime(2024, 1, 1, 0, 0, 15, 0);
- assertEquals("00", toCharUs("SS", second0));
- assertEquals("02", toCharUs("SS", second2));
- assertEquals("15", toCharUs("SS", second15));
+ assertThat(toCharUs("SS", second0), is("00"));
+ assertThat(toCharUs("SS", second2), is("02"));
+ assertThat(toCharUs("SS", second15), is("15"));
- assertEquals("0", toCharUs("FMSS", second0));
- assertEquals("2", toCharUs("FMSS", second2));
- assertEquals("15", toCharUs("FMSS", second15));
+ assertThat(toCharUs("FMSS", second0), is("0"));
+ assertThat(toCharUs("FMSS", second2), is("2"));
+ assertThat(toCharUs("FMSS", second15), is("15"));
- assertEquals("00TH", toCharUs("SSTH", second0));
- assertEquals("02ND", toCharUs("SSTH", second2));
- assertEquals("15TH", toCharUs("SSTH", second15));
- assertEquals("00th", toCharUs("SSth", second0));
- assertEquals("02nd", toCharUs("SSth", second2));
- assertEquals("15th", toCharUs("SSth", second15));
+ assertThat(toCharUs("SSTH", second0), is("00TH"));
+ assertThat(toCharUs("SSTH", second2), is("02ND"));
+ assertThat(toCharUs("SSTH", second15), is("15TH"));
+ assertThat(toCharUs("SSth", second0), is("00th"));
+ assertThat(toCharUs("SSth", second2), is("02nd"));
+ assertThat(toCharUs("SSth", second15), is("15th"));
- assertEquals("2nd", toCharUs("FMSSth", second2));
- assertEquals("2nd", toCharUs("FMSSnd", second2));
+ assertThat(toCharUs("FMSSth", second2), is("2nd"));
+ assertThat(toCharUs("FMSSnd", second2), is("2nd"));
}
@ParameterizedTest
@@ -204,23 +205,23 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime ms2 = createDateTime(2024, 1, 1, 0, 0, 2, 2000000);
final ZonedDateTime ms15 = createDateTime(2024, 1, 1, 0, 0, 15, 15000000);
- assertEquals("000", toCharUs(pattern, ms0));
- assertEquals("002", toCharUs(pattern, ms2));
- assertEquals("015", toCharUs(pattern, ms15));
+ assertThat(toCharUs(pattern, ms0), is("000"));
+ assertThat(toCharUs(pattern, ms2), is("002"));
+ assertThat(toCharUs(pattern, ms15), is("015"));
- assertEquals("0", toCharUs("FM" + pattern, ms0));
- assertEquals("2", toCharUs("FM" + pattern, ms2));
- assertEquals("15", toCharUs("FM" + pattern, ms15));
+ assertThat(toCharUs("FM" + pattern, ms0), is("0"));
+ assertThat(toCharUs("FM" + pattern, ms2), is("2"));
+ assertThat(toCharUs("FM" + pattern, ms15), is("15"));
- assertEquals("000TH", toCharUs(pattern + "TH", ms0));
- assertEquals("002ND", toCharUs(pattern + "TH", ms2));
- assertEquals("015TH", toCharUs(pattern + "TH", ms15));
- assertEquals("000th", toCharUs(pattern + "th", ms0));
- assertEquals("002nd", toCharUs(pattern + "th", ms2));
- assertEquals("015th", toCharUs(pattern + "th", ms15));
+ assertThat(toCharUs(pattern + "TH", ms0), is("000TH"));
+ assertThat(toCharUs(pattern + "TH", ms2), is("002ND"));
+ assertThat(toCharUs(pattern + "TH", ms15), is("015TH"));
+ assertThat(toCharUs(pattern + "th", ms0), is("000th"));
+ assertThat(toCharUs(pattern + "th", ms2), is("002nd"));
+ assertThat(toCharUs(pattern + "th", ms15), is("015th"));
- assertEquals("2nd", toCharUs("FM" + pattern + "th", ms2));
- assertEquals("2nd", toCharUs("FM" + pattern + "nd", ms2));
+ assertThat(toCharUs("FM" + pattern + "th", ms2), is("2nd"));
+ assertThat(toCharUs("FM" + pattern + "nd", ms2), is("2nd"));
}
@Test void testUS() {
@@ -229,27 +230,27 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime us15 = createDateTime(2024, 1, 1, 0, 0, 0, 15000);
final ZonedDateTime usWithMs = createDateTime(2024, 1, 1, 0, 0, 0, 2015000);
- assertEquals("000000", toCharUs("US", us0));
- assertEquals("000002", toCharUs("US", us2));
- assertEquals("000015", toCharUs("US", us15));
- assertEquals("002015", toCharUs("US", usWithMs));
+ assertThat(toCharUs("US", us0), is("000000"));
+ assertThat(toCharUs("US", us2), is("000002"));
+ assertThat(toCharUs("US", us15), is("000015"));
+ assertThat(toCharUs("US", usWithMs), is("002015"));
- assertEquals("0", toCharUs("FMUS", us0));
- assertEquals("2", toCharUs("FMUS", us2));
- assertEquals("15", toCharUs("FMUS", us15));
- assertEquals("2015", toCharUs("FMUS", usWithMs));
+ assertThat(toCharUs("FMUS", us0), is("0"));
+ assertThat(toCharUs("FMUS", us2), is("2"));
+ assertThat(toCharUs("FMUS", us15), is("15"));
+ assertThat(toCharUs("FMUS", usWithMs), is("2015"));
- assertEquals("000000TH", toCharUs("USTH", us0));
- assertEquals("000002ND", toCharUs("USTH", us2));
- assertEquals("000015TH", toCharUs("USTH", us15));
- assertEquals("002015TH", toCharUs("USTH", usWithMs));
- assertEquals("000000th", toCharUs("USth", us0));
- assertEquals("000002nd", toCharUs("USth", us2));
- assertEquals("000015th", toCharUs("USth", us15));
- assertEquals("002015th", toCharUs("USth", usWithMs));
+ assertThat(toCharUs("USTH", us0), is("000000TH"));
+ assertThat(toCharUs("USTH", us2), is("000002ND"));
+ assertThat(toCharUs("USTH", us15), is("000015TH"));
+ assertThat(toCharUs("USTH", usWithMs), is("002015TH"));
+ assertThat(toCharUs("USth", us0), is("000000th"));
+ assertThat(toCharUs("USth", us2), is("000002nd"));
+ assertThat(toCharUs("USth", us15), is("000015th"));
+ assertThat(toCharUs("USth", usWithMs), is("002015th"));
- assertEquals("2nd", toCharUs("FMUSth", us2));
- assertEquals("2nd", toCharUs("FMUSnd", us2));
+ assertThat(toCharUs("FMUSth", us2), is("2nd"));
+ assertThat(toCharUs("FMUSnd", us2), is("2nd"));
}
@Test void testFF1() {
@@ -257,23 +258,23 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime ms200 = createDateTime(2024, 1, 1, 0, 0, 0, 200_000_000);
final ZonedDateTime ms150 = createDateTime(2024, 1, 1, 0, 0, 0, 150_000_000);
- assertEquals("0", toCharUs("FF1", ms0));
- assertEquals("2", toCharUs("FF1", ms200));
- assertEquals("1", toCharUs("FF1", ms150));
+ assertThat(toCharUs("FF1", ms0), is("0"));
+ assertThat(toCharUs("FF1", ms200), is("2"));
+ assertThat(toCharUs("FF1", ms150), is("1"));
- assertEquals("0", toCharUs("FMFF1", ms0));
- assertEquals("2", toCharUs("FMFF1", ms200));
- assertEquals("1", toCharUs("FMFF1", ms150));
+ assertThat(toCharUs("FMFF1", ms0), is("0"));
+ assertThat(toCharUs("FMFF1", ms200), is("2"));
+ assertThat(toCharUs("FMFF1", ms150), is("1"));
- assertEquals("0TH", toCharUs("FF1TH", ms0));
- assertEquals("2ND", toCharUs("FF1TH", ms200));
- assertEquals("1ST", toCharUs("FF1TH", ms150));
- assertEquals("0th", toCharUs("FF1th", ms0));
- assertEquals("2nd", toCharUs("FF1th", ms200));
- assertEquals("1st", toCharUs("FF1th", ms150));
+ assertThat(toCharUs("FF1TH", ms0), is("0TH"));
+ assertThat(toCharUs("FF1TH", ms200), is("2ND"));
+ assertThat(toCharUs("FF1TH", ms150), is("1ST"));
+ assertThat(toCharUs("FF1th", ms0), is("0th"));
+ assertThat(toCharUs("FF1th", ms200), is("2nd"));
+ assertThat(toCharUs("FF1th", ms150), is("1st"));
- assertEquals("2nd", toCharUs("FMFF1th", ms200));
- assertEquals("2nd", toCharUs("FMFF1nd", ms200));
+ assertThat(toCharUs("FMFF1th", ms200), is("2nd"));
+ assertThat(toCharUs("FMFF1nd", ms200), is("2nd"));
}
@Test void testFF2() {
@@ -281,23 +282,23 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime ms20 = createDateTime(2024, 1, 1, 0, 0, 0, 20_000_000);
final ZonedDateTime ms150 = createDateTime(2024, 1, 1, 0, 0, 0, 150_000_000);
- assertEquals("00", toCharUs("FF2", ms0));
- assertEquals("02", toCharUs("FF2", ms20));
- assertEquals("15", toCharUs("FF2", ms150));
+ assertThat(toCharUs("FF2", ms0), is("00"));
+ assertThat(toCharUs("FF2", ms20), is("02"));
+ assertThat(toCharUs("FF2", ms150), is("15"));
- assertEquals("0", toCharUs("FMFF2", ms0));
- assertEquals("2", toCharUs("FMFF2", ms20));
- assertEquals("15", toCharUs("FMFF2", ms150));
+ assertThat(toCharUs("FMFF2", ms0), is("0"));
+ assertThat(toCharUs("FMFF2", ms20), is("2"));
+ assertThat(toCharUs("FMFF2", ms150), is("15"));
- assertEquals("00TH", toCharUs("FF2TH", ms0));
- assertEquals("02ND", toCharUs("FF2TH", ms20));
- assertEquals("15TH", toCharUs("FF2TH", ms150));
- assertEquals("00th", toCharUs("FF2th", ms0));
- assertEquals("02nd", toCharUs("FF2th", ms20));
- assertEquals("15th", toCharUs("FF2th", ms150));
+ assertThat(toCharUs("FF2TH", ms0), is("00TH"));
+ assertThat(toCharUs("FF2TH", ms20), is("02ND"));
+ assertThat(toCharUs("FF2TH", ms150), is("15TH"));
+ assertThat(toCharUs("FF2th", ms0), is("00th"));
+ assertThat(toCharUs("FF2th", ms20), is("02nd"));
+ assertThat(toCharUs("FF2th", ms150), is("15th"));
- assertEquals("2nd", toCharUs("FMFF2th", ms20));
- assertEquals("2nd", toCharUs("FMFF2nd", ms20));
+ assertThat(toCharUs("FMFF2th", ms20), is("2nd"));
+ assertThat(toCharUs("FMFF2nd", ms20), is("2nd"));
}
@Test void testFF4() {
@@ -305,23 +306,23 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime us200 = createDateTime(2024, 1, 1, 0, 0, 0, 200_000);
final ZonedDateTime ms150 = createDateTime(2024, 1, 1, 0, 0, 0, 150_000_000);
- assertEquals("0000", toCharUs("FF4", us0));
- assertEquals("0002", toCharUs("FF4", us200));
- assertEquals("1500", toCharUs("FF4", ms150));
+ assertThat(toCharUs("FF4", us0), is("0000"));
+ assertThat(toCharUs("FF4", us200), is("0002"));
+ assertThat(toCharUs("FF4", ms150), is("1500"));
- assertEquals("0", toCharUs("FMFF4", us0));
- assertEquals("2", toCharUs("FMFF4", us200));
- assertEquals("1500", toCharUs("FMFF4", ms150));
+ assertThat(toCharUs("FMFF4", us0), is("0"));
+ assertThat(toCharUs("FMFF4", us200), is("2"));
+ assertThat(toCharUs("FMFF4", ms150), is("1500"));
- assertEquals("0000TH", toCharUs("FF4TH", us0));
- assertEquals("0002ND", toCharUs("FF4TH", us200));
- assertEquals("1500TH", toCharUs("FF4TH", ms150));
- assertEquals("0000th", toCharUs("FF4th", us0));
- assertEquals("0002nd", toCharUs("FF4th", us200));
- assertEquals("1500th", toCharUs("FF4th", ms150));
+ assertThat(toCharUs("FF4TH", us0), is("0000TH"));
+ assertThat(toCharUs("FF4TH", us200), is("0002ND"));
+ assertThat(toCharUs("FF4TH", ms150), is("1500TH"));
+ assertThat(toCharUs("FF4th", us0), is("0000th"));
+ assertThat(toCharUs("FF4th", us200), is("0002nd"));
+ assertThat(toCharUs("FF4th", ms150), is("1500th"));
- assertEquals("2nd", toCharUs("FMFF4th", us200));
- assertEquals("2nd", toCharUs("FMFF4nd", us200));
+ assertThat(toCharUs("FMFF4th", us200), is("2nd"));
+ assertThat(toCharUs("FMFF4nd", us200), is("2nd"));
}
@Test void testFF5() {
@@ -329,23 +330,23 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime us20 = createDateTime(2024, 1, 1, 0, 0, 0, 20_000);
final ZonedDateTime ms150 = createDateTime(2024, 1, 1, 0, 0, 0, 150_000_000);
- assertEquals("00000", toCharUs("FF5", us0));
- assertEquals("00002", toCharUs("FF5", us20));
- assertEquals("15000", toCharUs("FF5", ms150));
+ assertThat(toCharUs("FF5", us0), is("00000"));
+ assertThat(toCharUs("FF5", us20), is("00002"));
+ assertThat(toCharUs("FF5", ms150), is("15000"));
- assertEquals("0", toCharUs("FMFF5", us0));
- assertEquals("2", toCharUs("FMFF5", us20));
- assertEquals("15000", toCharUs("FMFF5", ms150));
+ assertThat(toCharUs("FMFF5", us0), is("0"));
+ assertThat(toCharUs("FMFF5", us20), is("2"));
+ assertThat(toCharUs("FMFF5", ms150), is("15000"));
- assertEquals("00000TH", toCharUs("FF5TH", us0));
- assertEquals("00002ND", toCharUs("FF5TH", us20));
- assertEquals("15000TH", toCharUs("FF5TH", ms150));
- assertEquals("00000th", toCharUs("FF5th", us0));
- assertEquals("00002nd", toCharUs("FF5th", us20));
- assertEquals("15000th", toCharUs("FF5th", ms150));
+ assertThat(toCharUs("FF5TH", us0), is("00000TH"));
+ assertThat(toCharUs("FF5TH", us20), is("00002ND"));
+ assertThat(toCharUs("FF5TH", ms150), is("15000TH"));
+ assertThat(toCharUs("FF5th", us0), is("00000th"));
+ assertThat(toCharUs("FF5th", us20), is("00002nd"));
+ assertThat(toCharUs("FF5th", ms150), is("15000th"));
- assertEquals("2nd", toCharUs("FMFF5th", us20));
- assertEquals("2nd", toCharUs("FMFF5nd", us20));
+ assertThat(toCharUs("FMFF5th", us20), is("2nd"));
+ assertThat(toCharUs("FMFF5nd", us20), is("2nd"));
}
@Test void testFF6() {
@@ -353,23 +354,23 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime us2 = createDateTime(2024, 1, 1, 0, 0, 0, 2_000);
final ZonedDateTime ms150 = createDateTime(2024, 1, 1, 0, 0, 0, 150_000_000);
- assertEquals("000000", toCharUs("FF6", us0));
- assertEquals("000002", toCharUs("FF6", us2));
- assertEquals("150000", toCharUs("FF6", ms150));
+ assertThat(toCharUs("FF6", us0), is("000000"));
+ assertThat(toCharUs("FF6", us2), is("000002"));
+ assertThat(toCharUs("FF6", ms150), is("150000"));
- assertEquals("0", toCharUs("FMFF6", us0));
- assertEquals("2", toCharUs("FMFF6", us2));
- assertEquals("150000", toCharUs("FMFF6", ms150));
+ assertThat(toCharUs("FMFF6", us0), is("0"));
+ assertThat(toCharUs("FMFF6", us2), is("2"));
+ assertThat(toCharUs("FMFF6", ms150), is("150000"));
- assertEquals("000000TH", toCharUs("FF6TH", us0));
- assertEquals("000002ND", toCharUs("FF6TH", us2));
- assertEquals("150000TH", toCharUs("FF6TH", ms150));
- assertEquals("000000th", toCharUs("FF6th", us0));
- assertEquals("000002nd", toCharUs("FF6th", us2));
- assertEquals("150000th", toCharUs("FF6th", ms150));
+ assertThat(toCharUs("FF6TH", us0), is("000000TH"));
+ assertThat(toCharUs("FF6TH", us2), is("000002ND"));
+ assertThat(toCharUs("FF6TH", ms150), is("150000TH"));
+ assertThat(toCharUs("FF6th", us0), is("000000th"));
+ assertThat(toCharUs("FF6th", us2), is("000002nd"));
+ assertThat(toCharUs("FF6th", ms150), is("150000th"));
- assertEquals("2nd", toCharUs("FMFF6th", us2));
- assertEquals("2nd", toCharUs("FMFF6nd", us2));
+ assertThat(toCharUs("FMFF6th", us2), is("2nd"));
+ assertThat(toCharUs("FMFF6nd", us2), is("2nd"));
}
@ParameterizedTest
@@ -380,10 +381,10 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime noon = createDateTime(2024, 1, 1, 12, 0, 0, 0);
final ZonedDateTime evening = createDateTime(2024, 1, 1, 18, 0, 0, 0);
- assertEquals("AM", toCharUs(pattern, midnight));
- assertEquals("AM", toCharUs(pattern, morning));
- assertEquals("PM", toCharUs(pattern, noon));
- assertEquals("PM", toCharUs(pattern, evening));
+ assertThat(toCharUs(pattern, midnight), is("AM"));
+ assertThat(toCharUs(pattern, morning), is("AM"));
+ assertThat(toCharUs(pattern, noon), is("PM"));
+ assertThat(toCharUs(pattern, evening), is("PM"));
}
@ParameterizedTest
@@ -394,10 +395,10 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime noon = createDateTime(2024, 1, 1, 12, 0, 0, 0);
final ZonedDateTime evening = createDateTime(2024, 1, 1, 18, 0, 0, 0);
- assertEquals("am", toCharUs(pattern, midnight));
- assertEquals("am", toCharUs(pattern, morning));
- assertEquals("pm", toCharUs(pattern, noon));
- assertEquals("pm", toCharUs(pattern, evening));
+ assertThat(toCharUs(pattern, midnight), is("am"));
+ assertThat(toCharUs(pattern, morning), is("am"));
+ assertThat(toCharUs(pattern, noon), is("pm"));
+ assertThat(toCharUs(pattern, evening), is("pm"));
}
@ParameterizedTest
@@ -408,10 +409,10 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime noon = createDateTime(2024, 1, 1, 12, 0, 0, 0);
final ZonedDateTime evening = createDateTime(2024, 1, 1, 18, 0, 0, 0);
- assertEquals("A.M.", toCharUs(pattern, midnight));
- assertEquals("A.M.", toCharUs(pattern, morning));
- assertEquals("P.M.", toCharUs(pattern, noon));
- assertEquals("P.M.", toCharUs(pattern, evening));
+ assertThat(toCharUs(pattern, midnight), is("A.M."));
+ assertThat(toCharUs(pattern, morning), is("A.M."));
+ assertThat(toCharUs(pattern, noon), is("P.M."));
+ assertThat(toCharUs(pattern, evening), is("P.M."));
}
@ParameterizedTest
@@ -422,10 +423,10 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime noon = createDateTime(2024, 1, 1, 12, 0, 0, 0);
final ZonedDateTime evening = createDateTime(2024, 1, 1, 18, 0, 0, 0);
- assertEquals("a.m.", toCharUs(pattern, midnight));
- assertEquals("a.m.", toCharUs(pattern, morning));
- assertEquals("p.m.", toCharUs(pattern, noon));
- assertEquals("p.m.", toCharUs(pattern, evening));
+ assertThat(toCharUs(pattern, midnight), is("a.m."));
+ assertThat(toCharUs(pattern, morning), is("a.m."));
+ assertThat(toCharUs(pattern, noon), is("p.m."));
+ assertThat(toCharUs(pattern, evening), is("p.m."));
}
@Test void testYearWithCommas() {
@@ -434,25 +435,25 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime year3 = createDateTime(1, 1, 1, 0, 0, 0, 0);
final ZonedDateTime year4 = createDateTime(32136, 1, 1, 0, 0, 0, 0);
- assertEquals("2,024", toCharUs("Y,YYY", year1));
- assertEquals("0,100", toCharUs("Y,YYY", year2));
- assertEquals("0,001", toCharUs("Y,YYY", year3));
- assertEquals("32,136", toCharUs("Y,YYY", year4));
- assertEquals("2,024", toCharUs("FMY,YYY", year1));
- assertEquals("0,100", toCharUs("FMY,YYY", year2));
- assertEquals("0,001", toCharUs("FMY,YYY", year3));
- assertEquals("32,136", toCharUs("FMY,YYY", year4));
+ assertThat(toCharUs("Y,YYY", year1), is("2,024"));
+ assertThat(toCharUs("Y,YYY", year2), is("0,100"));
+ assertThat(toCharUs("Y,YYY", year3), is("0,001"));
+ assertThat(toCharUs("Y,YYY", year4), is("32,136"));
+ assertThat(toCharUs("FMY,YYY", year1), is("2,024"));
+ assertThat(toCharUs("FMY,YYY", year2), is("0,100"));
+ assertThat(toCharUs("FMY,YYY", year3), is("0,001"));
+ assertThat(toCharUs("FMY,YYY", year4), is("32,136"));
- assertEquals("2,024TH", toCharUs("Y,YYYTH", year1));
- assertEquals("0,100TH", toCharUs("Y,YYYTH", year2));
- assertEquals("0,001ST", toCharUs("Y,YYYTH", year3));
- assertEquals("32,136TH", toCharUs("Y,YYYTH", year4));
- assertEquals("2,024th", toCharUs("Y,YYYth", year1));
- assertEquals("0,100th", toCharUs("Y,YYYth", year2));
- assertEquals("0,001st", toCharUs("Y,YYYth", year3));
- assertEquals("32,136th", toCharUs("Y,YYYth", year4));
+ assertThat(toCharUs("Y,YYYTH", year1), is("2,024TH"));
+ assertThat(toCharUs("Y,YYYTH", year2), is("0,100TH"));
+ assertThat(toCharUs("Y,YYYTH", year3), is("0,001ST"));
+ assertThat(toCharUs("Y,YYYTH", year4), is("32,136TH"));
+ assertThat(toCharUs("Y,YYYth", year1), is("2,024th"));
+ assertThat(toCharUs("Y,YYYth", year2), is("0,100th"));
+ assertThat(toCharUs("Y,YYYth", year3), is("0,001st"));
+ assertThat(toCharUs("Y,YYYth", year4), is("32,136th"));
- assertEquals("2,024th", toCharUs("FMY,YYYth", year1));
+ assertThat(toCharUs("FMY,YYYth", year1), is("2,024th"));
}
@Test void testYYYY() {
@@ -461,25 +462,25 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime year3 = createDateTime(1, 1, 1, 0, 0, 0, 0);
final ZonedDateTime year4 = createDateTime(32136, 1, 1, 0, 0, 0, 0);
- assertEquals("2024", toCharUs("YYYY", year1));
- assertEquals("0100", toCharUs("YYYY", year2));
- assertEquals("0001", toCharUs("YYYY", year3));
- assertEquals("32136", toCharUs("YYYY", year4));
- assertEquals("2024", toCharUs("FMYYYY", year1));
- assertEquals("100", toCharUs("FMYYYY", year2));
- assertEquals("1", toCharUs("FMYYYY", year3));
- assertEquals("32136", toCharUs("FMYYYY", year4));
+ assertThat(toCharUs("YYYY", year1), is("2024"));
+ assertThat(toCharUs("YYYY", year2), is("0100"));
+ assertThat(toCharUs("YYYY", year3), is("0001"));
+ assertThat(toCharUs("YYYY", year4), is("32136"));
+ assertThat(toCharUs("FMYYYY", year1), is("2024"));
+ assertThat(toCharUs("FMYYYY", year2), is("100"));
+ assertThat(toCharUs("FMYYYY", year3), is("1"));
+ assertThat(toCharUs("FMYYYY", year4), is("32136"));
- assertEquals("2024TH", toCharUs("YYYYTH", year1));
- assertEquals("0100TH", toCharUs("YYYYTH", year2));
- assertEquals("0001ST", toCharUs("YYYYTH", year3));
- assertEquals("32136TH", toCharUs("YYYYTH", year4));
- assertEquals("2024th", toCharUs("YYYYth", year1));
- assertEquals("0100th", toCharUs("YYYYth", year2));
- assertEquals("0001st", toCharUs("YYYYth", year3));
- assertEquals("32136th", toCharUs("YYYYth", year4));
+ assertThat(toCharUs("YYYYTH", year1), is("2024TH"));
+ assertThat(toCharUs("YYYYTH", year2), is("0100TH"));
+ assertThat(toCharUs("YYYYTH", year3), is("0001ST"));
+ assertThat(toCharUs("YYYYTH", year4), is("32136TH"));
+ assertThat(toCharUs("YYYYth", year1), is("2024th"));
+ assertThat(toCharUs("YYYYth", year2), is("0100th"));
+ assertThat(toCharUs("YYYYth", year3), is("0001st"));
+ assertThat(toCharUs("YYYYth", year4), is("32136th"));
- assertEquals("2024th", toCharUs("FMYYYYth", year1));
+ assertThat(toCharUs("FMYYYYth", year1), is("2024th"));
}
@Test void testYYY() {
@@ -488,25 +489,25 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime year3 = createDateTime(1, 1, 1, 0, 0, 0, 0);
final ZonedDateTime year4 = createDateTime(32136, 1, 1, 0, 0, 0, 0);
- assertEquals("024", toCharUs("YYY", year1));
- assertEquals("100", toCharUs("YYY", year2));
- assertEquals("001", toCharUs("YYY", year3));
- assertEquals("136", toCharUs("YYY", year4));
- assertEquals("24", toCharUs("FMYYY", year1));
- assertEquals("100", toCharUs("FMYYY", year2));
- assertEquals("1", toCharUs("FMYYY", year3));
- assertEquals("136", toCharUs("FMYYY", year4));
+ assertThat(toCharUs("YYY", year1), is("024"));
+ assertThat(toCharUs("YYY", year2), is("100"));
+ assertThat(toCharUs("YYY", year3), is("001"));
+ assertThat(toCharUs("YYY", year4), is("136"));
+ assertThat(toCharUs("FMYYY", year1), is("24"));
+ assertThat(toCharUs("FMYYY", year2), is("100"));
+ assertThat(toCharUs("FMYYY", year3), is("1"));
+ assertThat(toCharUs("FMYYY", year4), is("136"));
- assertEquals("024TH", toCharUs("YYYTH", year1));
- assertEquals("100TH", toCharUs("YYYTH", year2));
- assertEquals("001ST", toCharUs("YYYTH", year3));
- assertEquals("136TH", toCharUs("YYYTH", year4));
- assertEquals("024th", toCharUs("YYYth", year1));
- assertEquals("100th", toCharUs("YYYth", year2));
- assertEquals("001st", toCharUs("YYYth", year3));
- assertEquals("136th", toCharUs("YYYth", year4));
+ assertThat(toCharUs("YYYTH", year1), is("024TH"));
+ assertThat(toCharUs("YYYTH", year2), is("100TH"));
+ assertThat(toCharUs("YYYTH", year3), is("001ST"));
+ assertThat(toCharUs("YYYTH", year4), is("136TH"));
+ assertThat(toCharUs("YYYth", year1), is("024th"));
+ assertThat(toCharUs("YYYth", year2), is("100th"));
+ assertThat(toCharUs("YYYth", year3), is("001st"));
+ assertThat(toCharUs("YYYth", year4), is("136th"));
- assertEquals("24th", toCharUs("FMYYYth", year1));
+ assertThat(toCharUs("FMYYYth", year1), is("24th"));
}
@Test void testYY() {
@@ -515,25 +516,25 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime year3 = createDateTime(1, 1, 1, 0, 0, 0, 0);
final ZonedDateTime year4 = createDateTime(32136, 1, 1, 0, 0, 0, 0);
- assertEquals("24", toCharUs("YY", year1));
- assertEquals("00", toCharUs("YY", year2));
- assertEquals("01", toCharUs("YY", year3));
- assertEquals("36", toCharUs("YY", year4));
- assertEquals("24", toCharUs("FMYY", year1));
- assertEquals("0", toCharUs("FMYY", year2));
- assertEquals("1", toCharUs("FMYY", year3));
- assertEquals("36", toCharUs("FMYY", year4));
+ assertThat(toCharUs("YY", year1), is("24"));
+ assertThat(toCharUs("YY", year2), is("00"));
+ assertThat(toCharUs("YY", year3), is("01"));
+ assertThat(toCharUs("YY", year4), is("36"));
+ assertThat(toCharUs("FMYY", year1), is("24"));
+ assertThat(toCharUs("FMYY", year2), is("0"));
+ assertThat(toCharUs("FMYY", year3), is("1"));
+ assertThat(toCharUs("FMYY", year4), is("36"));
- assertEquals("24TH", toCharUs("YYTH", year1));
- assertEquals("00TH", toCharUs("YYTH", year2));
- assertEquals("01ST", toCharUs("YYTH", year3));
- assertEquals("36TH", toCharUs("YYTH", year4));
- assertEquals("24th", toCharUs("YYth", year1));
- assertEquals("00th", toCharUs("YYth", year2));
- assertEquals("01st", toCharUs("YYth", year3));
- assertEquals("36th", toCharUs("YYth", year4));
+ assertThat(toCharUs("YYTH", year1), is("24TH"));
+ assertThat(toCharUs("YYTH", year2), is("00TH"));
+ assertThat(toCharUs("YYTH", year3), is("01ST"));
+ assertThat(toCharUs("YYTH", year4), is("36TH"));
+ assertThat(toCharUs("YYth", year1), is("24th"));
+ assertThat(toCharUs("YYth", year2), is("00th"));
+ assertThat(toCharUs("YYth", year3), is("01st"));
+ assertThat(toCharUs("YYth", year4), is("36th"));
- assertEquals("24th", toCharUs("FMYYth", year1));
+ assertThat(toCharUs("FMYYth", year1), is("24th"));
}
@Test void testY() {
@@ -542,25 +543,25 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime year3 = createDateTime(1, 1, 1, 0, 0, 0, 0);
final ZonedDateTime year4 = createDateTime(32136, 1, 1, 0, 0, 0, 0);
- assertEquals("4", toCharUs("Y", year1));
- assertEquals("0", toCharUs("Y", year2));
- assertEquals("1", toCharUs("Y", year3));
- assertEquals("6", toCharUs("Y", year4));
- assertEquals("4", toCharUs("FMY", year1));
- assertEquals("0", toCharUs("FMY", year2));
- assertEquals("1", toCharUs("FMY", year3));
- assertEquals("6", toCharUs("FMY", year4));
+ assertThat(toCharUs("Y", year1), is("4"));
+ assertThat(toCharUs("Y", year2), is("0"));
+ assertThat(toCharUs("Y", year3), is("1"));
+ assertThat(toCharUs("Y", year4), is("6"));
+ assertThat(toCharUs("FMY", year1), is("4"));
+ assertThat(toCharUs("FMY", year2), is("0"));
+ assertThat(toCharUs("FMY", year3), is("1"));
+ assertThat(toCharUs("FMY", year4), is("6"));
- assertEquals("4TH", toCharUs("YTH", year1));
- assertEquals("0TH", toCharUs("YTH", year2));
- assertEquals("1ST", toCharUs("YTH", year3));
- assertEquals("6TH", toCharUs("YTH", year4));
- assertEquals("4th", toCharUs("Yth", year1));
- assertEquals("0th", toCharUs("Yth", year2));
- assertEquals("1st", toCharUs("Yth", year3));
- assertEquals("6th", toCharUs("Yth", year4));
+ assertThat(toCharUs("YTH", year1), is("4TH"));
+ assertThat(toCharUs("YTH", year2), is("0TH"));
+ assertThat(toCharUs("YTH", year3), is("1ST"));
+ assertThat(toCharUs("YTH", year4), is("6TH"));
+ assertThat(toCharUs("Yth", year1), is("4th"));
+ assertThat(toCharUs("Yth", year2), is("0th"));
+ assertThat(toCharUs("Yth", year3), is("1st"));
+ assertThat(toCharUs("Yth", year4), is("6th"));
- assertEquals("4th", toCharUs("FMYth", year1));
+ assertThat(toCharUs("FMYth", year1), is("4th"));
}
@Test void testIYYY() {
@@ -570,29 +571,29 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date4 = date3.plusDays(1);
final ZonedDateTime date5 = date4.plusDays(1);
- assertEquals("2019", toCharUs("IYYY", date1));
- assertEquals("2020", toCharUs("IYYY", date2));
- assertEquals("2020", toCharUs("IYYY", date3));
- assertEquals("2020", toCharUs("IYYY", date4));
- assertEquals("2020", toCharUs("IYYY", date5));
- assertEquals("2019", toCharUs("FMIYYY", date1));
- assertEquals("2020", toCharUs("FMIYYY", date2));
- assertEquals("2020", toCharUs("FMIYYY", date3));
- assertEquals("2020", toCharUs("FMIYYY", date4));
- assertEquals("2020", toCharUs("FMIYYY", date5));
-
- assertEquals("2019TH", toCharUs("IYYYTH", date1));
- assertEquals("2020TH", toCharUs("IYYYTH", date2));
- assertEquals("2020TH", toCharUs("IYYYTH", date3));
- assertEquals("2020TH", toCharUs("IYYYTH", date4));
- assertEquals("2020TH", toCharUs("IYYYTH", date5));
- assertEquals("2019th", toCharUs("IYYYth", date1));
- assertEquals("2020th", toCharUs("IYYYth", date2));
- assertEquals("2020th", toCharUs("IYYYth", date3));
- assertEquals("2020th", toCharUs("IYYYth", date4));
- assertEquals("2020th", toCharUs("IYYYth", date5));
-
- assertEquals("2020th", toCharUs("FMIYYYth", date5));
+ assertThat(toCharUs("IYYY", date1), is("2019"));
+ assertThat(toCharUs("IYYY", date2), is("2020"));
+ assertThat(toCharUs("IYYY", date3), is("2020"));
+ assertThat(toCharUs("IYYY", date4), is("2020"));
+ assertThat(toCharUs("IYYY", date5), is("2020"));
+ assertThat(toCharUs("FMIYYY", date1), is("2019"));
+ assertThat(toCharUs("FMIYYY", date2), is("2020"));
+ assertThat(toCharUs("FMIYYY", date3), is("2020"));
+ assertThat(toCharUs("FMIYYY", date4), is("2020"));
+ assertThat(toCharUs("FMIYYY", date5), is("2020"));
+
+ assertThat(toCharUs("IYYYTH", date1), is("2019TH"));
+ assertThat(toCharUs("IYYYTH", date2), is("2020TH"));
+ assertThat(toCharUs("IYYYTH", date3), is("2020TH"));
+ assertThat(toCharUs("IYYYTH", date4), is("2020TH"));
+ assertThat(toCharUs("IYYYTH", date5), is("2020TH"));
+ assertThat(toCharUs("IYYYth", date1), is("2019th"));
+ assertThat(toCharUs("IYYYth", date2), is("2020th"));
+ assertThat(toCharUs("IYYYth", date3), is("2020th"));
+ assertThat(toCharUs("IYYYth", date4), is("2020th"));
+ assertThat(toCharUs("IYYYth", date5), is("2020th"));
+
+ assertThat(toCharUs("FMIYYYth", date5), is("2020th"));
}
@Test void testIYY() {
@@ -602,29 +603,29 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date4 = date3.plusDays(1);
final ZonedDateTime date5 = date4.plusDays(1);
- assertEquals("019", toCharUs("IYY", date1));
- assertEquals("020", toCharUs("IYY", date2));
- assertEquals("020", toCharUs("IYY", date3));
- assertEquals("020", toCharUs("IYY", date4));
- assertEquals("020", toCharUs("IYY", date5));
- assertEquals("19", toCharUs("FMIYY", date1));
- assertEquals("20", toCharUs("FMIYY", date2));
- assertEquals("20", toCharUs("FMIYY", date3));
- assertEquals("20", toCharUs("FMIYY", date4));
- assertEquals("20", toCharUs("FMIYY", date5));
-
- assertEquals("019TH", toCharUs("IYYTH", date1));
- assertEquals("020TH", toCharUs("IYYTH", date2));
- assertEquals("020TH", toCharUs("IYYTH", date3));
- assertEquals("020TH", toCharUs("IYYTH", date4));
- assertEquals("020TH", toCharUs("IYYTH", date5));
- assertEquals("019th", toCharUs("IYYth", date1));
- assertEquals("020th", toCharUs("IYYth", date2));
- assertEquals("020th", toCharUs("IYYth", date3));
- assertEquals("020th", toCharUs("IYYth", date4));
- assertEquals("020th", toCharUs("IYYth", date5));
-
- assertEquals("20th", toCharUs("FMIYYth", date5));
+ assertThat(toCharUs("IYY", date1), is("019"));
+ assertThat(toCharUs("IYY", date2), is("020"));
+ assertThat(toCharUs("IYY", date3), is("020"));
+ assertThat(toCharUs("IYY", date4), is("020"));
+ assertThat(toCharUs("IYY", date5), is("020"));
+ assertThat(toCharUs("FMIYY", date1), is("19"));
+ assertThat(toCharUs("FMIYY", date2), is("20"));
+ assertThat(toCharUs("FMIYY", date3), is("20"));
+ assertThat(toCharUs("FMIYY", date4), is("20"));
+ assertThat(toCharUs("FMIYY", date5), is("20"));
+
+ assertThat(toCharUs("IYYTH", date1), is("019TH"));
+ assertThat(toCharUs("IYYTH", date2), is("020TH"));
+ assertThat(toCharUs("IYYTH", date3), is("020TH"));
+ assertThat(toCharUs("IYYTH", date4), is("020TH"));
+ assertThat(toCharUs("IYYTH", date5), is("020TH"));
+ assertThat(toCharUs("IYYth", date1), is("019th"));
+ assertThat(toCharUs("IYYth", date2), is("020th"));
+ assertThat(toCharUs("IYYth", date3), is("020th"));
+ assertThat(toCharUs("IYYth", date4), is("020th"));
+ assertThat(toCharUs("IYYth", date5), is("020th"));
+
+ assertThat(toCharUs("FMIYYth", date5), is("20th"));
}
@Test void testIY() {
@@ -634,29 +635,29 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date4 = date3.plusDays(1);
final ZonedDateTime date5 = date4.plusDays(1);
- assertEquals("19", toCharUs("IY", date1));
- assertEquals("20", toCharUs("IY", date2));
- assertEquals("20", toCharUs("IY", date3));
- assertEquals("20", toCharUs("IY", date4));
- assertEquals("20", toCharUs("IY", date5));
- assertEquals("19", toCharUs("FMIY", date1));
- assertEquals("20", toCharUs("FMIY", date2));
- assertEquals("20", toCharUs("FMIY", date3));
- assertEquals("20", toCharUs("FMIY", date4));
- assertEquals("20", toCharUs("FMIY", date5));
-
- assertEquals("19TH", toCharUs("IYTH", date1));
- assertEquals("20TH", toCharUs("IYTH", date2));
- assertEquals("20TH", toCharUs("IYTH", date3));
- assertEquals("20TH", toCharUs("IYTH", date4));
- assertEquals("20TH", toCharUs("IYTH", date5));
- assertEquals("19th", toCharUs("IYth", date1));
- assertEquals("20th", toCharUs("IYth", date2));
- assertEquals("20th", toCharUs("IYth", date3));
- assertEquals("20th", toCharUs("IYth", date4));
- assertEquals("20th", toCharUs("IYth", date5));
-
- assertEquals("20th", toCharUs("FMIYth", date5));
+ assertThat(toCharUs("IY", date1), is("19"));
+ assertThat(toCharUs("IY", date2), is("20"));
+ assertThat(toCharUs("IY", date3), is("20"));
+ assertThat(toCharUs("IY", date4), is("20"));
+ assertThat(toCharUs("IY", date5), is("20"));
+ assertThat(toCharUs("FMIY", date1), is("19"));
+ assertThat(toCharUs("FMIY", date2), is("20"));
+ assertThat(toCharUs("FMIY", date3), is("20"));
+ assertThat(toCharUs("FMIY", date4), is("20"));
+ assertThat(toCharUs("FMIY", date5), is("20"));
+
+ assertThat(toCharUs("IYTH", date1), is("19TH"));
+ assertThat(toCharUs("IYTH", date2), is("20TH"));
+ assertThat(toCharUs("IYTH", date3), is("20TH"));
+ assertThat(toCharUs("IYTH", date4), is("20TH"));
+ assertThat(toCharUs("IYTH", date5), is("20TH"));
+ assertThat(toCharUs("IYth", date1), is("19th"));
+ assertThat(toCharUs("IYth", date2), is("20th"));
+ assertThat(toCharUs("IYth", date3), is("20th"));
+ assertThat(toCharUs("IYth", date4), is("20th"));
+ assertThat(toCharUs("IYth", date5), is("20th"));
+
+ assertThat(toCharUs("FMIYth", date5), is("20th"));
}
@Test void testI() {
@@ -666,29 +667,29 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date4 = date3.plusDays(1);
final ZonedDateTime date5 = date4.plusDays(1);
- assertEquals("9", toCharUs("I", date1));
- assertEquals("0", toCharUs("I", date2));
- assertEquals("0", toCharUs("I", date3));
- assertEquals("0", toCharUs("I", date4));
- assertEquals("0", toCharUs("I", date5));
- assertEquals("9", toCharUs("FMI", date1));
- assertEquals("0", toCharUs("FMI", date2));
- assertEquals("0", toCharUs("FMI", date3));
- assertEquals("0", toCharUs("FMI", date4));
- assertEquals("0", toCharUs("FMI", date5));
-
- assertEquals("9TH", toCharUs("ITH", date1));
- assertEquals("0TH", toCharUs("ITH", date2));
- assertEquals("0TH", toCharUs("ITH", date3));
- assertEquals("0TH", toCharUs("ITH", date4));
- assertEquals("0TH", toCharUs("ITH", date5));
- assertEquals("9th", toCharUs("Ith", date1));
- assertEquals("0th", toCharUs("Ith", date2));
- assertEquals("0th", toCharUs("Ith", date3));
- assertEquals("0th", toCharUs("Ith", date4));
- assertEquals("0th", toCharUs("Ith", date5));
-
- assertEquals("0th", toCharUs("FMIth", date5));
+ assertThat(toCharUs("I", date1), is("9"));
+ assertThat(toCharUs("I", date2), is("0"));
+ assertThat(toCharUs("I", date3), is("0"));
+ assertThat(toCharUs("I", date4), is("0"));
+ assertThat(toCharUs("I", date5), is("0"));
+ assertThat(toCharUs("FMI", date1), is("9"));
+ assertThat(toCharUs("FMI", date2), is("0"));
+ assertThat(toCharUs("FMI", date3), is("0"));
+ assertThat(toCharUs("FMI", date4), is("0"));
+ assertThat(toCharUs("FMI", date5), is("0"));
+
+ assertThat(toCharUs("ITH", date1), is("9TH"));
+ assertThat(toCharUs("ITH", date2), is("0TH"));
+ assertThat(toCharUs("ITH", date3), is("0TH"));
+ assertThat(toCharUs("ITH", date4), is("0TH"));
+ assertThat(toCharUs("ITH", date5), is("0TH"));
+ assertThat(toCharUs("Ith", date1), is("9th"));
+ assertThat(toCharUs("Ith", date2), is("0th"));
+ assertThat(toCharUs("Ith", date3), is("0th"));
+ assertThat(toCharUs("Ith", date4), is("0th"));
+ assertThat(toCharUs("Ith", date5), is("0th"));
+
+ assertThat(toCharUs("FMIth", date5), is("0th"));
}
@Test void testIW() {
@@ -696,21 +697,21 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = date1.plusDays(1);
final ZonedDateTime date3 = date2.plusDays(186);
- assertEquals("52", toCharUs("IW", date1));
- assertEquals("01", toCharUs("IW", date2));
- assertEquals("27", toCharUs("IW", date3));
- assertEquals("52", toCharUs("FMIW", date1));
- assertEquals("1", toCharUs("FMIW", date2));
- assertEquals("27", toCharUs("FMIW", date3));
+ assertThat(toCharUs("IW", date1), is("52"));
+ assertThat(toCharUs("IW", date2), is("01"));
+ assertThat(toCharUs("IW", date3), is("27"));
+ assertThat(toCharUs("FMIW", date1), is("52"));
+ assertThat(toCharUs("FMIW", date2), is("1"));
+ assertThat(toCharUs("FMIW", date3), is("27"));
- assertEquals("52ND", toCharUs("IWTH", date1));
- assertEquals("01ST", toCharUs("IWTH", date2));
- assertEquals("27TH", toCharUs("IWTH", date3));
- assertEquals("52nd", toCharUs("IWth", date1));
- assertEquals("01st", toCharUs("IWth", date2));
- assertEquals("27th", toCharUs("IWth", date3));
+ assertThat(toCharUs("IWTH", date1), is("52ND"));
+ assertThat(toCharUs("IWTH", date2), is("01ST"));
+ assertThat(toCharUs("IWTH", date3), is("27TH"));
+ assertThat(toCharUs("IWth", date1), is("52nd"));
+ assertThat(toCharUs("IWth", date2), is("01st"));
+ assertThat(toCharUs("IWth", date3), is("27th"));
- assertEquals("27th", toCharUs("FMIWth", date3));
+ assertThat(toCharUs("FMIWth", date3), is("27th"));
}
@Test void testIDDD() {
@@ -718,21 +719,21 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = date1.plusDays(1);
final ZonedDateTime date3 = date2.plusDays(186);
- assertEquals("364", toCharUs("IDDD", date1));
- assertEquals("001", toCharUs("IDDD", date2));
- assertEquals("187", toCharUs("IDDD", date3));
- assertEquals("364", toCharUs("FMIDDD", date1));
- assertEquals("1", toCharUs("FMIDDD", date2));
- assertEquals("187", toCharUs("FMIDDD", date3));
+ assertThat(toCharUs("IDDD", date1), is("364"));
+ assertThat(toCharUs("IDDD", date2), is("001"));
+ assertThat(toCharUs("IDDD", date3), is("187"));
+ assertThat(toCharUs("FMIDDD", date1), is("364"));
+ assertThat(toCharUs("FMIDDD", date2), is("1"));
+ assertThat(toCharUs("FMIDDD", date3), is("187"));
- assertEquals("364TH", toCharUs("IDDDTH", date1));
- assertEquals("001ST", toCharUs("IDDDTH", date2));
- assertEquals("187TH", toCharUs("IDDDTH", date3));
- assertEquals("364th", toCharUs("IDDDth", date1));
- assertEquals("001st", toCharUs("IDDDth", date2));
- assertEquals("187th", toCharUs("IDDDth", date3));
+ assertThat(toCharUs("IDDDTH", date1), is("364TH"));
+ assertThat(toCharUs("IDDDTH", date2), is("001ST"));
+ assertThat(toCharUs("IDDDTH", date3), is("187TH"));
+ assertThat(toCharUs("IDDDth", date1), is("364th"));
+ assertThat(toCharUs("IDDDth", date2), is("001st"));
+ assertThat(toCharUs("IDDDth", date3), is("187th"));
- assertEquals("187th", toCharUs("FMIDDDth", date3));
+ assertThat(toCharUs("FMIDDDth", date3), is("187th"));
}
@Test void testID() {
@@ -740,21 +741,21 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = date1.plusDays(1);
final ZonedDateTime date3 = date2.plusDays(186);
- assertEquals("7", toCharUs("ID", date1));
- assertEquals("1", toCharUs("ID", date2));
- assertEquals("5", toCharUs("ID", date3));
- assertEquals("7", toCharUs("FMID", date1));
- assertEquals("1", toCharUs("FMID", date2));
- assertEquals("5", toCharUs("FMID", date3));
+ assertThat(toCharUs("ID", date1), is("7"));
+ assertThat(toCharUs("ID", date2), is("1"));
+ assertThat(toCharUs("ID", date3), is("5"));
+ assertThat(toCharUs("FMID", date1), is("7"));
+ assertThat(toCharUs("FMID", date2), is("1"));
+ assertThat(toCharUs("FMID", date3), is("5"));
- assertEquals("7TH", toCharUs("IDTH", date1));
- assertEquals("1ST", toCharUs("IDTH", date2));
- assertEquals("5TH", toCharUs("IDTH", date3));
- assertEquals("7th", toCharUs("IDth", date1));
- assertEquals("1st", toCharUs("IDth", date2));
- assertEquals("5th", toCharUs("IDth", date3));
+ assertThat(toCharUs("IDTH", date1), is("7TH"));
+ assertThat(toCharUs("IDTH", date2), is("1ST"));
+ assertThat(toCharUs("IDTH", date3), is("5TH"));
+ assertThat(toCharUs("IDth", date1), is("7th"));
+ assertThat(toCharUs("IDth", date2), is("1st"));
+ assertThat(toCharUs("IDth", date3), is("5th"));
- assertEquals("5th", toCharUs("FMIDth", date3));
+ assertThat(toCharUs("FMIDth", date3), is("5th"));
}
@ParameterizedTest
@@ -765,10 +766,10 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date3 = date2.minusYears(1);
final ZonedDateTime date4 = date3.minusYears(200);
- assertEquals("AD", toCharUs(pattern, date1));
- assertEquals("AD", toCharUs(pattern, date2));
- assertEquals("BC", toCharUs(pattern, date3));
- assertEquals("BC", toCharUs(pattern, date4));
+ assertThat(toCharUs(pattern, date1), is("AD"));
+ assertThat(toCharUs(pattern, date2), is("AD"));
+ assertThat(toCharUs(pattern, date3), is("BC"));
+ assertThat(toCharUs(pattern, date4), is("BC"));
}
@ParameterizedTest
@@ -779,10 +780,10 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date3 = date2.minusYears(1);
final ZonedDateTime date4 = date3.minusYears(200);
- assertEquals("ad", toCharUs(pattern, date1));
- assertEquals("ad", toCharUs(pattern, date2));
- assertEquals("bc", toCharUs(pattern, date3));
- assertEquals("bc", toCharUs(pattern, date4));
+ assertThat(toCharUs(pattern, date1), is("ad"));
+ assertThat(toCharUs(pattern, date2), is("ad"));
+ assertThat(toCharUs(pattern, date3), is("bc"));
+ assertThat(toCharUs(pattern, date4), is("bc"));
}
@ParameterizedTest
@@ -793,10 +794,10 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date3 = date2.minusYears(1);
final ZonedDateTime date4 = date3.minusYears(200);
- assertEquals("A.D.", toCharUs(pattern, date1));
- assertEquals("A.D.", toCharUs(pattern, date2));
- assertEquals("B.C.", toCharUs(pattern, date3));
- assertEquals("B.C.", toCharUs(pattern, date4));
+ assertThat(toCharUs(pattern, date1), is("A.D."));
+ assertThat(toCharUs(pattern, date2), is("A.D."));
+ assertThat(toCharUs(pattern, date3), is("B.C."));
+ assertThat(toCharUs(pattern, date4), is("B.C."));
}
@ParameterizedTest
@@ -807,10 +808,10 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date3 = date2.minusYears(1);
final ZonedDateTime date4 = date3.minusYears(200);
- assertEquals("a.d.", toCharUs(pattern, date1));
- assertEquals("a.d.", toCharUs(pattern, date2));
- assertEquals("b.c.", toCharUs(pattern, date3));
- assertEquals("b.c.", toCharUs(pattern, date4));
+ assertThat(toCharUs(pattern, date1), is("a.d."));
+ assertThat(toCharUs(pattern, date2), is("a.d."));
+ assertThat(toCharUs(pattern, date3), is("b.c."));
+ assertThat(toCharUs(pattern, date4), is("b.c."));
}
@Test void testMonthFullUpperCase() {
@@ -818,9 +819,9 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = createDateTime(2024, 3, 1, 23, 0, 0, 0);
final ZonedDateTime date3 = createDateTime(2024, 11, 1, 23, 0, 0, 0);
- assertEquals("JANUARY ", toCharUs("MONTH", date1));
- assertEquals("MARCH ", toCharUs("MONTH", date2));
- assertEquals("NOVEMBER ", toCharUs("MONTH", date3));
+ assertThat(toCharUs("MONTH", date1), is("JANUARY "));
+ assertThat(toCharUs("MONTH", date2), is("MARCH "));
+ assertThat(toCharUs("MONTH", date3), is("NOVEMBER "));
}
@Test void testMonthFullUpperCaseNoTranslate() {
@@ -828,9 +829,9 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = createDateTime(2024, 3, 1, 23, 0, 0, 0);
final ZonedDateTime date3 = createDateTime(2024, 11, 1, 23, 0, 0, 0);
- assertEquals("JANUARY ", toCharFrench("MONTH", date1));
- assertEquals("MARCH ", toCharFrench("MONTH", date2));
- assertEquals("NOVEMBER ", toCharFrench("MONTH", date3));
+ assertThat(toCharFrench("MONTH", date1), is("JANUARY "));
+ assertThat(toCharFrench("MONTH", date2), is("MARCH "));
+ assertThat(toCharFrench("MONTH", date3), is("NOVEMBER "));
}
@Test void testMonthFullUpperCaseTranslate() {
@@ -838,9 +839,9 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = createDateTime(2024, 3, 1, 23, 0, 0, 0);
final ZonedDateTime date3 = createDateTime(2024, 11, 1, 23, 0, 0, 0);
- assertEquals("JANVIER ", toCharFrench("TMMONTH", date1));
- assertEquals("MARS ", toCharFrench("TMMONTH", date2));
- assertEquals("NOVEMBRE ", toCharFrench("TMMONTH", date3));
+ assertThat(toCharFrench("TMMONTH", date1), is("JANVIER "));
+ assertThat(toCharFrench("TMMONTH", date2), is("MARS "));
+ assertThat(toCharFrench("TMMONTH", date3), is("NOVEMBRE "));
}
@Test void testMonthFullUpperCaseNoPadding() {
@@ -848,9 +849,9 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = createDateTime(2024, 3, 1, 23, 0, 0, 0);
final ZonedDateTime date3 = createDateTime(2024, 11, 1, 23, 0, 0, 0);
- assertEquals("JANUARY", toCharUs("FMMONTH", date1));
- assertEquals("MARCH", toCharUs("FMMONTH", date2));
- assertEquals("NOVEMBER", toCharUs("FMMONTH", date3));
+ assertThat(toCharUs("FMMONTH", date1), is("JANUARY"));
+ assertThat(toCharUs("FMMONTH", date2), is("MARCH"));
+ assertThat(toCharUs("FMMONTH", date3), is("NOVEMBER"));
}
@Test void testMonthFullCapitalized() {
@@ -858,9 +859,9 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = createDateTime(2024, 3, 1, 23, 0, 0, 0);
final ZonedDateTime date3 = createDateTime(2024, 11, 1, 23, 0, 0, 0);
- assertEquals("January ", toCharUs("Month", date1));
- assertEquals("March ", toCharUs("Month", date2));
- assertEquals("November ", toCharUs("Month", date3));
+ assertThat(toCharUs("Month", date1), is("January "));
+ assertThat(toCharUs("Month", date2), is("March "));
+ assertThat(toCharUs("Month", date3), is("November "));
}
@Test void testMonthFullLowerCase() {
@@ -868,9 +869,9 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = createDateTime(2024, 3, 1, 23, 0, 0, 0);
final ZonedDateTime date3 = createDateTime(2024, 11, 1, 23, 0, 0, 0);
- assertEquals("january ", toCharUs("month", date1));
- assertEquals("march ", toCharUs("month", date2));
- assertEquals("november ", toCharUs("month", date3));
+ assertThat(toCharUs("month", date1), is("january "));
+ assertThat(toCharUs("month", date2), is("march "));
+ assertThat(toCharUs("month", date3), is("november "));
}
@Test void testMonthShortUpperCase() {
@@ -878,9 +879,9 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = createDateTime(2024, 3, 1, 23, 0, 0, 0);
final ZonedDateTime date3 = createDateTime(2024, 11, 1, 23, 0, 0, 0);
- assertEquals("JAN", toCharUs("MON", date1));
- assertEquals("MAR", toCharUs("MON", date2));
- assertEquals("NOV", toCharUs("MON", date3));
+ assertThat(toCharUs("MON", date1), is("JAN"));
+ assertThat(toCharUs("MON", date2), is("MAR"));
+ assertThat(toCharUs("MON", date3), is("NOV"));
}
@Test void testMonthShortCapitalized() {
@@ -888,9 +889,9 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = createDateTime(2024, 3, 1, 23, 0, 0, 0);
final ZonedDateTime date3 = createDateTime(2024, 11, 1, 23, 0, 0, 0);
- assertEquals("Jan", toCharUs("Mon", date1));
- assertEquals("Mar", toCharUs("Mon", date2));
- assertEquals("Nov", toCharUs("Mon", date3));
+ assertThat(toCharUs("Mon", date1), is("Jan"));
+ assertThat(toCharUs("Mon", date2), is("Mar"));
+ assertThat(toCharUs("Mon", date3), is("Nov"));
}
@Test void testMonthShortLowerCase() {
@@ -898,9 +899,9 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = createDateTime(2024, 3, 1, 23, 0, 0, 0);
final ZonedDateTime date3 = createDateTime(2024, 11, 1, 23, 0, 0, 0);
- assertEquals("jan", toCharUs("mon", date1));
- assertEquals("mar", toCharUs("mon", date2));
- assertEquals("nov", toCharUs("mon", date3));
+ assertThat(toCharUs("mon", date1), is("jan"));
+ assertThat(toCharUs("mon", date2), is("mar"));
+ assertThat(toCharUs("mon", date3), is("nov"));
}
@Test void testMM() {
@@ -908,21 +909,21 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = createDateTime(2024, 3, 1, 23, 0, 0, 0);
final ZonedDateTime date3 = createDateTime(2024, 11, 1, 23, 0, 0, 0);
- assertEquals("01", toCharUs("MM", date1));
- assertEquals("03", toCharUs("MM", date2));
- assertEquals("11", toCharUs("MM", date3));
- assertEquals("1", toCharUs("FMMM", date1));
- assertEquals("3", toCharUs("FMMM", date2));
- assertEquals("11", toCharUs("FMMM", date3));
+ assertThat(toCharUs("MM", date1), is("01"));
+ assertThat(toCharUs("MM", date2), is("03"));
+ assertThat(toCharUs("MM", date3), is("11"));
+ assertThat(toCharUs("FMMM", date1), is("1"));
+ assertThat(toCharUs("FMMM", date2), is("3"));
+ assertThat(toCharUs("FMMM", date3), is("11"));
- assertEquals("01ST", toCharUs("MMTH", date1));
- assertEquals("03RD", toCharUs("MMTH", date2));
- assertEquals("11TH", toCharUs("MMTH", date3));
- assertEquals("01st", toCharUs("MMth", date1));
- assertEquals("03rd", toCharUs("MMth", date2));
- assertEquals("11th", toCharUs("MMth", date3));
+ assertThat(toCharUs("MMTH", date1), is("01ST"));
+ assertThat(toCharUs("MMTH", date2), is("03RD"));
+ assertThat(toCharUs("MMTH", date3), is("11TH"));
+ assertThat(toCharUs("MMth", date1), is("01st"));
+ assertThat(toCharUs("MMth", date2), is("03rd"));
+ assertThat(toCharUs("MMth", date3), is("11th"));
- assertEquals("3rd", toCharUs("FMMMth", date2));
+ assertThat(toCharUs("FMMMth", date2), is("3rd"));
}
@Test void testDayFullUpperCase() {
@@ -930,9 +931,9 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = createDateTime(2024, 3, 1, 23, 0, 0, 0);
final ZonedDateTime date3 = createDateTime(2024, 10, 1, 23, 0, 0, 0);
- assertEquals("MONDAY ", toCharUs("DAY", date1));
- assertEquals("FRIDAY ", toCharUs("DAY", date2));
- assertEquals("TUESDAY ", toCharUs("DAY", date3));
+ assertThat(toCharUs("DAY", date1), is("MONDAY "));
+ assertThat(toCharUs("DAY", date2), is("FRIDAY "));
+ assertThat(toCharUs("DAY", date3), is("TUESDAY "));
}
@Test void testDayFullUpperNoTranslate() {
@@ -940,9 +941,9 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = createDateTime(2024, 3, 1, 23, 0, 0, 0);
final ZonedDateTime date3 = createDateTime(2024, 10, 1, 23, 0, 0, 0);
- assertEquals("MONDAY ", toCharFrench("DAY", date1));
- assertEquals("FRIDAY ", toCharFrench("DAY", date2));
- assertEquals("TUESDAY ", toCharFrench("DAY", date3));
+ assertThat(toCharFrench("DAY", date1), is("MONDAY "));
+ assertThat(toCharFrench("DAY", date2), is("FRIDAY "));
+ assertThat(toCharFrench("DAY", date3), is("TUESDAY "));
}
@Test void testDayFullUpperTranslate() {
@@ -950,9 +951,9 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = createDateTime(2024, 3, 1, 23, 0, 0, 0);
final ZonedDateTime date3 = createDateTime(2024, 10, 1, 23, 0, 0, 0);
- assertEquals("LUNDI ", toCharFrench("TMDAY", date1));
- assertEquals("VENDREDI ", toCharFrench("TMDAY", date2));
- assertEquals("MARDI ", toCharFrench("TMDAY", date3));
+ assertThat(toCharFrench("TMDAY", date1), is("LUNDI "));
+ assertThat(toCharFrench("TMDAY", date2), is("VENDREDI "));
+ assertThat(toCharFrench("TMDAY", date3), is("MARDI "));
}
@Test void testDayFullCapitalized() {
@@ -960,9 +961,9 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = createDateTime(2024, 3, 1, 23, 0, 0, 0);
final ZonedDateTime date3 = createDateTime(2024, 10, 1, 23, 0, 0, 0);
- assertEquals("Monday ", toCharUs("Day", date1));
- assertEquals("Friday ", toCharUs("Day", date2));
- assertEquals("Tuesday ", toCharUs("Day", date3));
+ assertThat(toCharUs("Day", date1), is("Monday "));
+ assertThat(toCharUs("Day", date2), is("Friday "));
+ assertThat(toCharUs("Day", date3), is("Tuesday "));
}
@Test void testDayFullLowerCase() {
@@ -970,9 +971,9 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = createDateTime(2024, 3, 1, 23, 0, 0, 0);
final ZonedDateTime date3 = createDateTime(2024, 10, 1, 23, 0, 0, 0);
- assertEquals("monday ", toCharUs("day", date1));
- assertEquals("friday ", toCharUs("day", date2));
- assertEquals("tuesday ", toCharUs("day", date3));
+ assertThat(toCharUs("day", date1), is("monday "));
+ assertThat(toCharUs("day", date2), is("friday "));
+ assertThat(toCharUs("day", date3), is("tuesday "));
}
@Test void testDayShortUpperCase() {
@@ -980,9 +981,9 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = createDateTime(2024, 3, 1, 23, 0, 0, 0);
final ZonedDateTime date3 = createDateTime(2024, 10, 1, 23, 0, 0, 0);
- assertEquals("MON", toCharUs("DY", date1));
- assertEquals("FRI", toCharUs("DY", date2));
- assertEquals("TUE", toCharUs("DY", date3));
+ assertThat(toCharUs("DY", date1), is("MON"));
+ assertThat(toCharUs("DY", date2), is("FRI"));
+ assertThat(toCharUs("DY", date3), is("TUE"));
}
@Test void testDayShortCapitalized() {
@@ -990,9 +991,9 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = createDateTime(2024, 3, 1, 23, 0, 0, 0);
final ZonedDateTime date3 = createDateTime(2024, 10, 1, 23, 0, 0, 0);
- assertEquals("Mon", toCharUs("Dy", date1));
- assertEquals("Fri", toCharUs("Dy", date2));
- assertEquals("Tue", toCharUs("Dy", date3));
+ assertThat(toCharUs("Dy", date1), is("Mon"));
+ assertThat(toCharUs("Dy", date2), is("Fri"));
+ assertThat(toCharUs("Dy", date3), is("Tue"));
}
@Test void testDayShortLowerCase() {
@@ -1000,9 +1001,9 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = createDateTime(2024, 3, 1, 23, 0, 0, 0);
final ZonedDateTime date3 = createDateTime(2024, 10, 1, 23, 0, 0, 0);
- assertEquals("mon", toCharUs("dy", date1));
- assertEquals("fri", toCharUs("dy", date2));
- assertEquals("tue", toCharUs("dy", date3));
+ assertThat(toCharUs("dy", date1), is("mon"));
+ assertThat(toCharUs("dy", date2), is("fri"));
+ assertThat(toCharUs("dy", date3), is("tue"));
}
@Test void testDDD() {
@@ -1010,21 +1011,21 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = createDateTime(2024, 3, 1, 23, 0, 0, 0);
final ZonedDateTime date3 = createDateTime(2024, 11, 1, 23, 0, 0, 0);
- assertEquals("001", toCharUs("DDD", date1));
- assertEquals("061", toCharUs("DDD", date2));
- assertEquals("306", toCharUs("DDD", date3));
- assertEquals("1", toCharUs("FMDDD", date1));
- assertEquals("61", toCharUs("FMDDD", date2));
- assertEquals("306", toCharUs("FMDDD", date3));
+ assertThat(toCharUs("DDD", date1), is("001"));
+ assertThat(toCharUs("DDD", date2), is("061"));
+ assertThat(toCharUs("DDD", date3), is("306"));
+ assertThat(toCharUs("FMDDD", date1), is("1"));
+ assertThat(toCharUs("FMDDD", date2), is("61"));
+ assertThat(toCharUs("FMDDD", date3), is("306"));
- assertEquals("001ST", toCharUs("DDDTH", date1));
- assertEquals("061ST", toCharUs("DDDTH", date2));
- assertEquals("306TH", toCharUs("DDDTH", date3));
- assertEquals("001st", toCharUs("DDDth", date1));
- assertEquals("061st", toCharUs("DDDth", date2));
- assertEquals("306th", toCharUs("DDDth", date3));
+ assertThat(toCharUs("DDDTH", date1), is("001ST"));
+ assertThat(toCharUs("DDDTH", date2), is("061ST"));
+ assertThat(toCharUs("DDDTH", date3), is("306TH"));
+ assertThat(toCharUs("DDDth", date1), is("001st"));
+ assertThat(toCharUs("DDDth", date2), is("061st"));
+ assertThat(toCharUs("DDDth", date3), is("306th"));
- assertEquals("1st", toCharUs("FMDDDth", date1));
+ assertThat(toCharUs("FMDDDth", date1), is("1st"));
}
@Test void testDD() {
@@ -1032,21 +1033,21 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = createDateTime(2024, 1, 12, 23, 0, 0, 0);
final ZonedDateTime date3 = createDateTime(2024, 1, 29, 23, 0, 0, 0);
- assertEquals("01", toCharUs("DD", date1));
- assertEquals("12", toCharUs("DD", date2));
- assertEquals("29", toCharUs("DD", date3));
- assertEquals("1", toCharUs("FMDD", date1));
- assertEquals("12", toCharUs("FMDD", date2));
- assertEquals("29", toCharUs("FMDD", date3));
+ assertThat(toCharUs("DD", date1), is("01"));
+ assertThat(toCharUs("DD", date2), is("12"));
+ assertThat(toCharUs("DD", date3), is("29"));
+ assertThat(toCharUs("FMDD", date1), is("1"));
+ assertThat(toCharUs("FMDD", date2), is("12"));
+ assertThat(toCharUs("FMDD", date3), is("29"));
- assertEquals("01ST", toCharUs("DDTH", date1));
- assertEquals("12TH", toCharUs("DDTH", date2));
- assertEquals("29TH", toCharUs("DDTH", date3));
- assertEquals("01st", toCharUs("DDth", date1));
- assertEquals("12th", toCharUs("DDth", date2));
- assertEquals("29th", toCharUs("DDth", date3));
+ assertThat(toCharUs("DDTH", date1), is("01ST"));
+ assertThat(toCharUs("DDTH", date2), is("12TH"));
+ assertThat(toCharUs("DDTH", date3), is("29TH"));
+ assertThat(toCharUs("DDth", date1), is("01st"));
+ assertThat(toCharUs("DDth", date2), is("12th"));
+ assertThat(toCharUs("DDth", date3), is("29th"));
- assertEquals("1st", toCharUs("FMDDth", date1));
+ assertThat(toCharUs("FMDDth", date1), is("1st"));
}
@Test void testD() {
@@ -1054,21 +1055,21 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = createDateTime(2024, 1, 2, 23, 0, 0, 0);
final ZonedDateTime date3 = createDateTime(2024, 1, 27, 23, 0, 0, 0);
- assertEquals("2", toCharUs("D", date1));
- assertEquals("3", toCharUs("D", date2));
- assertEquals("7", toCharUs("D", date3));
- assertEquals("2", toCharUs("FMD", date1));
- assertEquals("3", toCharUs("FMD", date2));
- assertEquals("7", toCharUs("FMD", date3));
+ assertThat(toCharUs("D", date1), is("2"));
+ assertThat(toCharUs("D", date2), is("3"));
+ assertThat(toCharUs("D", date3), is("7"));
+ assertThat(toCharUs("FMD", date1), is("2"));
+ assertThat(toCharUs("FMD", date2), is("3"));
+ assertThat(toCharUs("FMD", date3), is("7"));
- assertEquals("2ND", toCharUs("DTH", date1));
- assertEquals("3RD", toCharUs("DTH", date2));
- assertEquals("7TH", toCharUs("DTH", date3));
- assertEquals("2nd", toCharUs("Dth", date1));
- assertEquals("3rd", toCharUs("Dth", date2));
- assertEquals("7th", toCharUs("Dth", date3));
+ assertThat(toCharUs("DTH", date1), is("2ND"));
+ assertThat(toCharUs("DTH", date2), is("3RD"));
+ assertThat(toCharUs("DTH", date3), is("7TH"));
+ assertThat(toCharUs("Dth", date1), is("2nd"));
+ assertThat(toCharUs("Dth", date2), is("3rd"));
+ assertThat(toCharUs("Dth", date3), is("7th"));
- assertEquals("2nd", toCharUs("FMDth", date1));
+ assertThat(toCharUs("FMDth", date1), is("2nd"));
}
@Test void testWW() {
@@ -1076,21 +1077,21 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = createDateTime(2016, 3, 1, 23, 0, 0, 0);
final ZonedDateTime date3 = createDateTime(2016, 10, 1, 23, 0, 0, 0);
- assertEquals("1", toCharUs("WW", date1));
- assertEquals("9", toCharUs("WW", date2));
- assertEquals("40", toCharUs("WW", date3));
- assertEquals("1", toCharUs("FMWW", date1));
- assertEquals("9", toCharUs("FMWW", date2));
- assertEquals("40", toCharUs("FMWW", date3));
+ assertThat(toCharUs("WW", date1), is("1"));
+ assertThat(toCharUs("WW", date2), is("9"));
+ assertThat(toCharUs("WW", date3), is("40"));
+ assertThat(toCharUs("FMWW", date1), is("1"));
+ assertThat(toCharUs("FMWW", date2), is("9"));
+ assertThat(toCharUs("FMWW", date3), is("40"));
- assertEquals("1ST", toCharUs("WWTH", date1));
- assertEquals("9TH", toCharUs("WWTH", date2));
- assertEquals("40TH", toCharUs("WWTH", date3));
- assertEquals("1st", toCharUs("WWth", date1));
- assertEquals("9th", toCharUs("WWth", date2));
- assertEquals("40th", toCharUs("WWth", date3));
+ assertThat(toCharUs("WWTH", date1), is("1ST"));
+ assertThat(toCharUs("WWTH", date2), is("9TH"));
+ assertThat(toCharUs("WWTH", date3), is("40TH"));
+ assertThat(toCharUs("WWth", date1), is("1st"));
+ assertThat(toCharUs("WWth", date2), is("9th"));
+ assertThat(toCharUs("WWth", date3), is("40th"));
- assertEquals("1st", toCharUs("FMWWth", date1));
+ assertThat(toCharUs("FMWWth", date1), is("1st"));
}
@Test void testW() {
@@ -1098,21 +1099,21 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = createDateTime(2024, 1, 15, 23, 0, 0, 0);
final ZonedDateTime date3 = createDateTime(2024, 10, 31, 23, 0, 0, 0);
- assertEquals("1", toCharUs("W", date1));
- assertEquals("3", toCharUs("W", date2));
- assertEquals("5", toCharUs("W", date3));
- assertEquals("1", toCharUs("FMW", date1));
- assertEquals("3", toCharUs("FMW", date2));
- assertEquals("5", toCharUs("FMW", date3));
+ assertThat(toCharUs("W", date1), is("1"));
+ assertThat(toCharUs("W", date2), is("3"));
+ assertThat(toCharUs("W", date3), is("5"));
+ assertThat(toCharUs("FMW", date1), is("1"));
+ assertThat(toCharUs("FMW", date2), is("3"));
+ assertThat(toCharUs("FMW", date3), is("5"));
- assertEquals("1ST", toCharUs("WTH", date1));
- assertEquals("3RD", toCharUs("WTH", date2));
- assertEquals("5TH", toCharUs("WTH", date3));
- assertEquals("1st", toCharUs("Wth", date1));
- assertEquals("3rd", toCharUs("Wth", date2));
- assertEquals("5th", toCharUs("Wth", date3));
+ assertThat(toCharUs("WTH", date1), is("1ST"));
+ assertThat(toCharUs("WTH", date2), is("3RD"));
+ assertThat(toCharUs("WTH", date3), is("5TH"));
+ assertThat(toCharUs("Wth", date1), is("1st"));
+ assertThat(toCharUs("Wth", date2), is("3rd"));
+ assertThat(toCharUs("Wth", date3), is("5th"));
- assertEquals("1st", toCharUs("FMWth", date1));
+ assertThat(toCharUs("FMWth", date1), is("1st"));
}
@Test void testCC() {
@@ -1121,25 +1122,25 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date3 = date2.minusYears(1);
final ZonedDateTime date4 = date3.minusYears(200);
- assertEquals("21", toCharUs("CC", date1));
- assertEquals("01", toCharUs("CC", date2));
- assertEquals("-01", toCharUs("CC", date3));
- assertEquals("-03", toCharUs("CC", date4));
- assertEquals("21", toCharUs("FMCC", date1));
- assertEquals("1", toCharUs("FMCC", date2));
- assertEquals("-1", toCharUs("FMCC", date3));
- assertEquals("-3", toCharUs("FMCC", date4));
+ assertThat(toCharUs("CC", date1), is("21"));
+ assertThat(toCharUs("CC", date2), is("01"));
+ assertThat(toCharUs("CC", date3), is("-01"));
+ assertThat(toCharUs("CC", date4), is("-03"));
+ assertThat(toCharUs("FMCC", date1), is("21"));
+ assertThat(toCharUs("FMCC", date2), is("1"));
+ assertThat(toCharUs("FMCC", date3), is("-1"));
+ assertThat(toCharUs("FMCC", date4), is("-3"));
- assertEquals("21ST", toCharUs("CCTH", date1));
- assertEquals("01ST", toCharUs("CCTH", date2));
- assertEquals("-01ST", toCharUs("CCTH", date3));
- assertEquals("-03RD", toCharUs("CCTH", date4));
- assertEquals("21st", toCharUs("CCth", date1));
- assertEquals("01st", toCharUs("CCth", date2));
- assertEquals("-01st", toCharUs("CCth", date3));
- assertEquals("-03rd", toCharUs("CCth", date4));
+ assertThat(toCharUs("CCTH", date1), is("21ST"));
+ assertThat(toCharUs("CCTH", date2), is("01ST"));
+ assertThat(toCharUs("CCTH", date3), is("-01ST"));
+ assertThat(toCharUs("CCTH", date4), is("-03RD"));
+ assertThat(toCharUs("CCth", date1), is("21st"));
+ assertThat(toCharUs("CCth", date2), is("01st"));
+ assertThat(toCharUs("CCth", date3), is("-01st"));
+ assertThat(toCharUs("CCth", date4), is("-03rd"));
- assertEquals("-1st", toCharUs("FMCCth", date3));
+ assertThat(toCharUs("FMCCth", date3), is("-1st"));
}
@Test void testJ() {
@@ -1147,19 +1148,19 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date2 = date1.minusYears(2024);
final ZonedDateTime date3 = date2.minusYears(1000);
- assertEquals("2460311", toCharUs("J", date1));
- assertEquals("1721060", toCharUs("J", date2));
- assertEquals("1356183", toCharUs("J", date3));
- assertEquals("2460311", toCharUs("FMJ", date1));
- assertEquals("1721060", toCharUs("FMJ", date2));
- assertEquals("1356183", toCharUs("FMJ", date3));
+ assertThat(toCharUs("J", date1), is("2460311"));
+ assertThat(toCharUs("J", date2), is("1721060"));
+ assertThat(toCharUs("J", date3), is("1356183"));
+ assertThat(toCharUs("FMJ", date1), is("2460311"));
+ assertThat(toCharUs("FMJ", date2), is("1721060"));
+ assertThat(toCharUs("FMJ", date3), is("1356183"));
- assertEquals("2460311TH", toCharUs("JTH", date1));
- assertEquals("1721060TH", toCharUs("JTH", date2));
- assertEquals("1356183RD", toCharUs("JTH", date3));
- assertEquals("2460311th", toCharUs("Jth", date1));
- assertEquals("1721060th", toCharUs("Jth", date2));
- assertEquals("1356183rd", toCharUs("Jth", date3));
+ assertThat(toCharUs("JTH", date1), is("2460311TH"));
+ assertThat(toCharUs("JTH", date2), is("1721060TH"));
+ assertThat(toCharUs("JTH", date3), is("1356183RD"));
+ assertThat(toCharUs("Jth", date1), is("2460311th"));
+ assertThat(toCharUs("Jth", date2), is("1721060th"));
+ assertThat(toCharUs("Jth", date3), is("1356183rd"));
}
@Test void testQ() {
@@ -1168,23 +1169,23 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date3 = createDateTime(2024, 8, 23, 0, 0, 0, 0);
final ZonedDateTime date4 = createDateTime(2024, 12, 31, 0, 0, 0, 0);
- assertEquals("1", toCharUs("Q", date1));
- assertEquals("2", toCharUs("Q", date2));
- assertEquals("3", toCharUs("Q", date3));
- assertEquals("4", toCharUs("Q", date4));
- assertEquals("1", toCharUs("FMQ", date1));
- assertEquals("2", toCharUs("FMQ", date2));
- assertEquals("3", toCharUs("FMQ", date3));
- assertEquals("4", toCharUs("FMQ", date4));
-
- assertEquals("1ST", toCharUs("QTH", date1));
- assertEquals("2ND", toCharUs("QTH", date2));
- assertEquals("3RD", toCharUs("QTH", date3));
- assertEquals("4TH", toCharUs("QTH", date4));
- assertEquals("1st", toCharUs("Qth", date1));
- assertEquals("2nd", toCharUs("Qth", date2));
- assertEquals("3rd", toCharUs("Qth", date3));
- assertEquals("4th", toCharUs("Qth", date4));
+ assertThat(toCharUs("Q", date1), is("1"));
+ assertThat(toCharUs("Q", date2), is("2"));
+ assertThat(toCharUs("Q", date3), is("3"));
+ assertThat(toCharUs("Q", date4), is("4"));
+ assertThat(toCharUs("FMQ", date1), is("1"));
+ assertThat(toCharUs("FMQ", date2), is("2"));
+ assertThat(toCharUs("FMQ", date3), is("3"));
+ assertThat(toCharUs("FMQ", date4), is("4"));
+
+ assertThat(toCharUs("QTH", date1), is("1ST"));
+ assertThat(toCharUs("QTH", date2), is("2ND"));
+ assertThat(toCharUs("QTH", date3), is("3RD"));
+ assertThat(toCharUs("QTH", date4), is("4TH"));
+ assertThat(toCharUs("Qth", date1), is("1st"));
+ assertThat(toCharUs("Qth", date2), is("2nd"));
+ assertThat(toCharUs("Qth", date3), is("3rd"));
+ assertThat(toCharUs("Qth", date4), is("4th"));
}
@Test void testRMUpperCase() {
@@ -1193,10 +1194,10 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date3 = createDateTime(2024, 8, 23, 0, 0, 0, 0);
final ZonedDateTime date4 = createDateTime(2024, 12, 31, 0, 0, 0, 0);
- assertEquals("I", toCharUs("RM", date1));
- assertEquals("IV", toCharUs("RM", date2));
- assertEquals("VIII", toCharUs("RM", date3));
- assertEquals("XII", toCharUs("RM", date4));
+ assertThat(toCharUs("RM", date1), is("I"));
+ assertThat(toCharUs("RM", date2), is("IV"));
+ assertThat(toCharUs("RM", date3), is("VIII"));
+ assertThat(toCharUs("RM", date4), is("XII"));
}
@Test void testRMLowerCase() {
@@ -1205,474 +1206,506 @@ public class PostgresqlDateTimeFormatterTest {
final ZonedDateTime date3 = createDateTime(2024, 8, 23, 0, 0, 0, 0);
final ZonedDateTime date4 = createDateTime(2024, 12, 31, 0, 0, 0, 0);
- assertEquals("i", toCharUs("rm", date1));
- assertEquals("iv", toCharUs("rm", date2));
- assertEquals("viii", toCharUs("rm", date3));
- assertEquals("xii", toCharUs("rm", date4));
+ assertThat(toCharUs("rm", date1), is("i"));
+ assertThat(toCharUs("rm", date2), is("iv"));
+ assertThat(toCharUs("rm", date3), is("viii"));
+ assertThat(toCharUs("rm", date4), is("xii"));
}
@Test void testToTimestampHH() throws Exception {
- assertEquals(DAY_1_CE.plusHours(1), toTimestamp("01", "HH"));
- assertEquals(DAY_1_CE.plusHours(1), toTimestamp("1", "HH"));
- assertEquals(DAY_1_CE.plusHours(11), toTimestamp("11", "HH"));
+ assertThat(toTimestamp("01", "HH"), is(DAY_1_CE.plusHours(1)));
+ assertThat(toTimestamp("1", "HH"), is(DAY_1_CE.plusHours(1)));
+ assertThat(toTimestamp("11", "HH"), is(DAY_1_CE.plusHours(11)));
try {
- toTimestamp("72", "HH");
- fail();
+ ZonedDateTime x = toTimestamp("72", "HH");
+ fail("expected error, got " + x);
} catch (Exception e) {
+ assertThat(e.getMessage(), is("Parsed value outside of valid range"));
}
try {
- toTimestamp("abc", "HH");
- fail();
+ ZonedDateTime x = toTimestamp("abc", "HH");
+ fail("expected error, got " + x);
} catch (Exception e) {
+ assertThat(e.getMessage(), is("Unable to parse value"));
}
}
@Test void testToTimestampHH12() throws Exception {
- assertEquals(DAY_1_CE.plusHours(1), toTimestamp("01", "HH12"));
- assertEquals(DAY_1_CE.plusHours(1), toTimestamp("1", "HH12"));
- assertEquals(DAY_1_CE.plusHours(11), toTimestamp("11", "HH12"));
+ assertThat(toTimestamp("01", "HH12"), is(DAY_1_CE.plusHours(1)));
+ assertThat(toTimestamp("1", "HH12"), is(DAY_1_CE.plusHours(1)));
+ assertThat(toTimestamp("11", "HH12"), is(DAY_1_CE.plusHours(11)));
try {
- toTimestamp("72", "HH12");
- fail();
+ ZonedDateTime x = toTimestamp("72", "HH12");
+ fail("expected error, got " + x);
} catch (Exception e) {
}
try {
- toTimestamp("abc", "HH12");
- fail();
+ ZonedDateTime x = toTimestamp("abc", "HH12");
+ fail("expected error, got " + x);
} catch (Exception e) {
}
}
@Test void testToTimestampHH24() throws Exception {
- assertEquals(DAY_1_CE.plusHours(1), toTimestamp("01", "HH24"));
- assertEquals(DAY_1_CE.plusHours(1), toTimestamp("1", "HH24"));
- assertEquals(DAY_1_CE.plusHours(18), toTimestamp("18", "HH24"));
+ assertThat(toTimestamp("01", "HH24"), is(DAY_1_CE.plusHours(1)));
+ assertThat(toTimestamp("1", "HH24"), is(DAY_1_CE.plusHours(1)));
+ assertThat(toTimestamp("18", "HH24"), is(DAY_1_CE.plusHours(18)));
try {
- toTimestamp("72", "HH24");
- fail();
+ ZonedDateTime x = toTimestamp("72", "HH24");
+ fail("expected error, got " + x);
} catch (Exception e) {
+ assertThat(e.getMessage(), is("Parsed value outside of valid range"));
}
try {
- toTimestamp("abc", "HH24");
- fail();
+ ZonedDateTime x = toTimestamp("abc", "HH24");
+ fail("expected error, got " + x);
} catch (Exception e) {
+ assertThat(e.getMessage(), is("Unable to parse value"));
}
}
@Test void testToTimestampMI() throws Exception {
- assertEquals(DAY_1_CE.plusMinutes(1), toTimestamp("01", "MI"));
- assertEquals(DAY_1_CE.plusMinutes(1), toTimestamp("1", "MI"));
- assertEquals(DAY_1_CE.plusMinutes(57), toTimestamp("57", "MI"));
+ assertThat(toTimestamp("01", "MI"), is(DAY_1_CE.plusMinutes(1)));
+ assertThat(toTimestamp("1", "MI"), is(DAY_1_CE.plusMinutes(1)));
+ assertThat(toTimestamp("57", "MI"), is(DAY_1_CE.plusMinutes(57)));
try {
- toTimestamp("72", "MI");
- fail();
+ ZonedDateTime x = toTimestamp("72", "MI");
+ fail("expected error, got " + x);
} catch (Exception e) {
+ assertThat(e.getMessage(), is("Parsed value outside of valid range"));
}
try {
- toTimestamp("abc", "MI");
- fail();
+ ZonedDateTime x = toTimestamp("abc", "MI");
+ fail("expected error, got " + x);
} catch (Exception e) {
+ assertThat(e.getMessage(), is("Unable to parse value"));
}
}
@Test void testToTimestampSS() throws Exception {
- assertEquals(DAY_1_CE.plusSeconds(1), toTimestamp("01", "SS"));
- assertEquals(DAY_1_CE.plusSeconds(1), toTimestamp("1", "SS"));
- assertEquals(DAY_1_CE.plusSeconds(57), toTimestamp("57", "SS"));
+ assertThat(toTimestamp("01", "SS"), is(DAY_1_CE.plusSeconds(1)));
+ assertThat(toTimestamp("1", "SS"), is(DAY_1_CE.plusSeconds(1)));
+ assertThat(toTimestamp("57", "SS"), is(DAY_1_CE.plusSeconds(57)));
try {
- toTimestamp("72", "SS");
- fail();
+ ZonedDateTime x = toTimestamp("72", "SS");
+ fail("expected error, got " + x);
} catch (Exception e) {
+ assertThat(e.getMessage(), is("Parsed value outside of valid range"));
}
try {
- toTimestamp("abc", "SS");
- fail();
+ ZonedDateTime x = toTimestamp("abc", "SS");
+ fail("expected error, got " + x);
} catch (Exception e) {
+ assertThat(e.getMessage(), is("Unable to parse value"));
}
}
@Test void testToTimestampMS() throws Exception {
- assertEquals(DAY_1_CE.plusNanos(1_000_000), toTimestamp("001", "MS"));
- assertEquals(DAY_1_CE.plusNanos(1_000_000), toTimestamp("1", "MS"));
- assertEquals(DAY_1_CE.plusNanos(999_000_000), toTimestamp("999", "MS"));
+ assertThat(toTimestamp("001", "MS"), is(DAY_1_CE.plusNanos(1_000_000)));
+ assertThat(toTimestamp("1", "MS"), is(DAY_1_CE.plusNanos(1_000_000)));
+ assertThat(toTimestamp("999", "MS"), is(DAY_1_CE.plusNanos(999_000_000)));
try {
- toTimestamp("9999", "MS");
- fail();
+ ZonedDateTime x = toTimestamp("9999", "MS");
+ fail("expected error, got " + x);
} catch (Exception e) {
+ assertThat(e.getMessage(), is("Parsed value outside of valid range"));
}
try {
- toTimestamp("abc", "MS");
- fail();
+ ZonedDateTime x = toTimestamp("abc", "MS");
+ fail("expected error, got " + x);
} catch (Exception e) {
+ assertThat(e.getMessage(), is("Unable to parse value"));
}
}
@Test void testToTimestampUS() throws Exception {
- assertEquals(DAY_1_CE.plusNanos(1_000), toTimestamp("001", "US"));
- assertEquals(DAY_1_CE.plusNanos(1_000), toTimestamp("1", "US"));
- assertEquals(DAY_1_CE.plusNanos(999_000), toTimestamp("999", "US"));
+ assertThat(toTimestamp("001", "US"), is(DAY_1_CE.plusNanos(1_000)));
+ assertThat(toTimestamp("1", "US"), is(DAY_1_CE.plusNanos(1_000)));
+ assertThat(toTimestamp("999", "US"), is(DAY_1_CE.plusNanos(999_000)));
try {
- toTimestamp("9999999", "US");
- fail();
+ ZonedDateTime x = toTimestamp("9999999", "US");
+ fail("expected error, got " + x);
} catch (Exception e) {
}
try {
- toTimestamp("abc", "US");
- fail();
+ ZonedDateTime x = toTimestamp("abc", "US");
+ fail("expected error, got " + x);
} catch (Exception e) {
}
}
@Test void testToTimestampFF1() throws Exception {
- assertEquals(DAY_1_CE.plusNanos(100_000_000), toTimestamp("1", "FF1"));
- assertEquals(DAY_1_CE.plusNanos(900_000_000), toTimestamp("9", "FF1"));
+ assertThat(toTimestamp("1", "FF1"), is(DAY_1_CE.plusNanos(100_000_000)));
+ assertThat(toTimestamp("9", "FF1"), is(DAY_1_CE.plusNanos(900_000_000)));
try {
- toTimestamp("72", "FF1");
- fail();
+ ZonedDateTime x = toTimestamp("72", "FF1");
+ fail("expected error, got " + x);
} catch (Exception e) {
+ assertThat(e.getMessage(), is("Parsed value outside of valid range"));
}
try {
- toTimestamp("abc", "FF1");
- fail();
+ ZonedDateTime x = toTimestamp("abc", "FF1");
+ fail("expected error, got " + x);
} catch (Exception e) {
+ assertThat(e.getMessage(), is("Unable to parse value"));
}
}
@Test void testToTimestampFF2() throws Exception {
- assertEquals(DAY_1_CE.plusNanos(10_000_000), toTimestamp("01", "FF2"));
- assertEquals(DAY_1_CE.plusNanos(10_000_000), toTimestamp("1", "FF2"));
- assertEquals(DAY_1_CE.plusNanos(970_000_000), toTimestamp("97", "FF2"));
+ assertThat(toTimestamp("01", "FF2"), is(DAY_1_CE.plusNanos(10_000_000)));
+ assertThat(toTimestamp("1", "FF2"), is(DAY_1_CE.plusNanos(10_000_000)));
+ assertThat(toTimestamp("97", "FF2"), is(DAY_1_CE.plusNanos(970_000_000)));
try {
- toTimestamp("999", "FF2");
- fail();
+ ZonedDateTime x = toTimestamp("999", "FF2");
+ fail("expected error, got " + x);
} catch (Exception e) {
+ assertThat(e.getMessage(), is("Parsed value outside of valid range"));
}
try {
- toTimestamp("abc", "FF2");
- fail();
+ ZonedDateTime x = toTimestamp("abc", "FF2");
+ fail("expected error, got " + x);
} catch (Exception e) {
+ assertThat(e.getMessage(), is("Unable to parse value"));
}
}
@Test void testToTimestampFF3() throws Exception {
- assertEquals(DAY_1_CE.plusNanos(1_000_000), toTimestamp("001", "FF3"));
- assertEquals(DAY_1_CE.plusNanos(1_000_000), toTimestamp("1", "FF3"));
- assertEquals(DAY_1_CE.plusNanos(976_000_000), toTimestamp("976", "FF3"));
+ assertThat(toTimestamp("001", "FF3"), is(DAY_1_CE.plusNanos(1_000_000)));
+ assertThat(toTimestamp("1", "FF3"), is(DAY_1_CE.plusNanos(1_000_000)));
+ assertThat(toTimestamp("976", "FF3"), is(DAY_1_CE.plusNanos(976_000_000)));
}
@Test void testToTimestampFF4() throws Exception {
- assertEquals(DAY_1_CE.plusNanos(100_000), toTimestamp("0001", "FF4"));
- assertEquals(DAY_1_CE.plusNanos(100_000), toTimestamp("1", "FF4"));
- assertEquals(DAY_1_CE.plusNanos(976_200_000), toTimestamp("9762", "FF4"));
+ assertThat(toTimestamp("0001", "FF4"), is(DAY_1_CE.plusNanos(100_000)));
+ assertThat(toTimestamp("1", "FF4"), is(DAY_1_CE.plusNanos(100_000)));
+ assertThat(toTimestamp("9762", "FF4"), is(DAY_1_CE.plusNanos(976_200_000)));
}
@Test void testToTimestampFF5() throws Exception {
- assertEquals(DAY_1_CE.plusNanos(10_000), toTimestamp("00001", "FF5"));
- assertEquals(DAY_1_CE.plusNanos(10_000), toTimestamp("1", "FF5"));
- assertEquals(DAY_1_CE.plusNanos(976_210_000), toTimestamp("97621", "FF5"));
+ assertThat(toTimestamp("00001", "FF5"), is(DAY_1_CE.plusNanos(10_000)));
+ assertThat(toTimestamp("1", "FF5"), is(DAY_1_CE.plusNanos(10_000)));
+ assertThat(toTimestamp("97621", "FF5"), is(DAY_1_CE.plusNanos(976_210_000)));
}
@Test void testToTimestampFF6() throws Exception {
- assertEquals(DAY_1_CE.plusNanos(1_000), toTimestamp("000001", "FF6"));
- assertEquals(DAY_1_CE.plusNanos(1_000), toTimestamp("1", "FF6"));
- assertEquals(DAY_1_CE.plusNanos(976_214_000), toTimestamp("976214", "FF6"));
+ assertThat(toTimestamp("000001", "FF6"), is(DAY_1_CE.plusNanos(1_000)));
+ assertThat(toTimestamp("1", "FF6"), is(DAY_1_CE.plusNanos(1_000)));
+ assertThat(toTimestamp("976214", "FF6"), is(DAY_1_CE.plusNanos(976_214_000)));
}
@Test void testToTimestampAMPM() throws Exception {
- assertEquals(DAY_1_CE.plusHours(3), toTimestamp("03AM", "HH12AM"));
- assertEquals(DAY_1_CE.plusHours(3), toTimestamp("03AM", "HH12PM"));
- assertEquals(DAY_1_CE.plusHours(15), toTimestamp("03PM", "HH12AM"));
- assertEquals(DAY_1_CE.plusHours(15), toTimestamp("03PM", "HH12PM"));
- assertEquals(DAY_1_CE.plusHours(3), toTimestamp("03A.M.", "HH12A.M."));
- assertEquals(DAY_1_CE.plusHours(3), toTimestamp("03A.M.", "HH12P.M."));
- assertEquals(DAY_1_CE.plusHours(15), toTimestamp("03P.M.", "HH12A.M."));
- assertEquals(DAY_1_CE.plusHours(15), toTimestamp("03P.M.", "HH12P.M."));
- assertEquals(DAY_1_CE.plusHours(3), toTimestamp("03am", "HH12am"));
- assertEquals(DAY_1_CE.plusHours(3), toTimestamp("03am", "HH12pm"));
- assertEquals(DAY_1_CE.plusHours(15), toTimestamp("03pm", "HH12am"));
- assertEquals(DAY_1_CE.plusHours(15), toTimestamp("03pm", "HH12pm"));
- assertEquals(DAY_1_CE.plusHours(3), toTimestamp("03a.m.", "HH12a.m."));
- assertEquals(DAY_1_CE.plusHours(3), toTimestamp("03a.m.", "HH12p.m."));
- assertEquals(DAY_1_CE.plusHours(15), toTimestamp("03p.m.", "HH12a.m."));
- assertEquals(DAY_1_CE.plusHours(15), toTimestamp("03p.m.", "HH12p.m."));
+ assertThat(toTimestamp("03AM", "HH12AM"), is(DAY_1_CE.plusHours(3)));
+ assertThat(toTimestamp("03AM", "HH12PM"), is(DAY_1_CE.plusHours(3)));
+ assertThat(toTimestamp("03PM", "HH12AM"), is(DAY_1_CE.plusHours(15)));
+ assertThat(toTimestamp("03PM", "HH12PM"), is(DAY_1_CE.plusHours(15)));
+ assertThat(toTimestamp("03A.M.", "HH12A.M."), is(DAY_1_CE.plusHours(3)));
+ assertThat(toTimestamp("03A.M.", "HH12P.M."), is(DAY_1_CE.plusHours(3)));
+ assertThat(toTimestamp("03P.M.", "HH12A.M."), is(DAY_1_CE.plusHours(15)));
+ assertThat(toTimestamp("03P.M.", "HH12P.M."), is(DAY_1_CE.plusHours(15)));
+ assertThat(toTimestamp("03am", "HH12am"), is(DAY_1_CE.plusHours(3)));
+ assertThat(toTimestamp("03am", "HH12pm"), is(DAY_1_CE.plusHours(3)));
+ assertThat(toTimestamp("03pm", "HH12am"), is(DAY_1_CE.plusHours(15)));
+ assertThat(toTimestamp("03pm", "HH12pm"), is(DAY_1_CE.plusHours(15)));
+ assertThat(toTimestamp("03a.m.", "HH12a.m."), is(DAY_1_CE.plusHours(3)));
+ assertThat(toTimestamp("03a.m.", "HH12p.m."), is(DAY_1_CE.plusHours(3)));
+ assertThat(toTimestamp("03p.m.", "HH12a.m."), is(DAY_1_CE.plusHours(15)));
+ assertThat(toTimestamp("03p.m.", "HH12p.m."), is(DAY_1_CE.plusHours(15)));
}
@Test void testToTimestampYYYYWithCommas() throws Exception {
- assertEquals(DAY_1_CE, toTimestamp("0,001", "Y,YYY"));
- assertEquals(JAN_1_2024, toTimestamp("2,024", "Y,YYY"));
+ assertThat(toTimestamp("0,001", "Y,YYY"), is(DAY_1_CE));
+ assertThat(toTimestamp("2,024", "Y,YYY"), is(JAN_1_2024));
}
@Test void testToTimestampYYYY() throws Exception {
- assertEquals(DAY_1_CE, toTimestamp("0001", "YYYY"));
- assertEquals(DAY_1_CE, toTimestamp("1", "YYYY"));
- assertEquals(JAN_1_2024, toTimestamp("2024", "YYYY"));
+ assertThat(toTimestamp("0001", "YYYY"), is(DAY_1_CE));
+ assertThat(toTimestamp("1", "YYYY"), is(DAY_1_CE));
+ assertThat(toTimestamp("2024", "YYYY"), is(JAN_1_2024));
}
@Test void testToTimestampYYY() throws Exception {
- assertEquals(JAN_1_2001, toTimestamp("001", "YYY"));
- assertEquals(JAN_1_2001, toTimestamp("1", "YYY"));
- assertEquals(createDateTime(1987, 1, 1, 0, 0, 0, 0), toTimestamp("987", "YYY"));
+ assertThat(toTimestamp("001", "YYY"), is(JAN_1_2001));
+ assertThat(toTimestamp("1", "YYY"), is(JAN_1_2001));
+ assertThat(toTimestamp("987", "YYY"),
+ is(createDateTime(1987, 1, 1, 0, 0, 0, 0)));
}
@Test void testToTimestampYY() throws Exception {
- assertEquals(JAN_1_2001, toTimestamp("01", "YY"));
- assertEquals(JAN_1_2001, toTimestamp("1", "YY"));
- assertEquals(JAN_1_2024, toTimestamp("24", "YY"));
+ assertThat(toTimestamp("01", "YY"), is(JAN_1_2001));
+ assertThat(toTimestamp("1", "YY"), is(JAN_1_2001));
+ assertThat(toTimestamp("24", "YY"), is(JAN_1_2024));
}
@Test void testToTimestampY() throws Exception {
- assertEquals(JAN_1_2001, toTimestamp("1", "Y"));
- assertEquals(JAN_1_2001.plusYears(3), toTimestamp("4", "Y"));
+ assertThat(toTimestamp("1", "Y"), is(JAN_1_2001));
+ assertThat(toTimestamp("4", "Y"), is(JAN_1_2001.plusYears(3)));
}
@Test void testToTimestampIYYY() throws Exception {
- assertEquals(DAY_1_CE, toTimestamp("0001", "IYYY"));
- assertEquals(DAY_1_CE, toTimestamp("1", "IYYY"));
- assertEquals(JAN_1_2024, toTimestamp("2024", "IYYY"));
+ assertThat(toTimestamp("0001", "IYYY"), is(DAY_1_CE));
+ assertThat(toTimestamp("1", "IYYY"), is(DAY_1_CE));
+ assertThat(toTimestamp("2024", "IYYY"), is(JAN_1_2024));
}
@Test void testToTimestampIYY() throws Exception {
- assertEquals(JAN_1_2001, toTimestamp("001", "IYY"));
- assertEquals(JAN_1_2001, toTimestamp("1", "IYY"));
- assertEquals(createDateTime(1987, 1, 1, 0, 0, 0, 0), toTimestamp("987", "IYY"));
+ assertThat(toTimestamp("001", "IYY"), is(JAN_1_2001));
+ assertThat(toTimestamp("1", "IYY"), is(JAN_1_2001));
+ assertThat(toTimestamp("987", "IYY"),
+ is(createDateTime(1987, 1, 1, 0, 0, 0, 0)));
}
@Test void testToTimestampIY() throws Exception {
- assertEquals(JAN_1_2001, toTimestamp("01", "IY"));
- assertEquals(JAN_1_2001, toTimestamp("1", "IY"));
- assertEquals(JAN_1_2024, toTimestamp("24", "IY"));
+ assertThat(toTimestamp("01", "IY"), is(JAN_1_2001));
+ assertThat(toTimestamp("1", "IY"), is(JAN_1_2001));
+ assertThat(toTimestamp("24", "IY"), is(JAN_1_2024));
}
@Test void testToTimestampI() throws Exception {
- assertEquals(JAN_1_2001, toTimestamp("1", "I"));
- assertEquals(JAN_1_2001, toTimestamp("1", "I"));
- assertEquals(JAN_1_2001.plusYears(3), toTimestamp("4", "I"));
+ assertThat(toTimestamp("1", "I"), is(JAN_1_2001));
+ assertThat(toTimestamp("1", "I"), is(JAN_1_2001));
+ assertThat(toTimestamp("4", "I"), is(JAN_1_2001.plusYears(3)));
}
@Test void testToTimestampBCAD() throws Exception {
- assertEquals(0, toTimestamp("1920BC", "YYYYBC").get(ChronoField.ERA));
- assertEquals(0, toTimestamp("1920BC", "YYYYAD").get(ChronoField.ERA));
- assertEquals(1, toTimestamp("1920AD", "YYYYBC").get(ChronoField.ERA));
- assertEquals(1, toTimestamp("1920AD", "YYYYAD").get(ChronoField.ERA));
- assertEquals(0, toTimestamp("1920B.C.", "YYYYB.C.").get(ChronoField.ERA));
- assertEquals(0, toTimestamp("1920B.C.", "YYYYA.D.").get(ChronoField.ERA));
- assertEquals(1, toTimestamp("1920A.D.", "YYYYB.C.").get(ChronoField.ERA));
- assertEquals(1, toTimestamp("1920A.D.", "YYYYA.D.").get(ChronoField.ERA));
- assertEquals(0, toTimestamp("1920bc", "YYYYbc").get(ChronoField.ERA));
- assertEquals(0, toTimestamp("1920bc", "YYYYad").get(ChronoField.ERA));
- assertEquals(1, toTimestamp("1920ad", "YYYYbc").get(ChronoField.ERA));
- assertEquals(1, toTimestamp("1920ad", "YYYYad").get(ChronoField.ERA));
- assertEquals(0, toTimestamp("1920b.c.", "YYYYb.c.").get(ChronoField.ERA));
- assertEquals(0, toTimestamp("1920b.c.", "YYYYa.d.").get(ChronoField.ERA));
- assertEquals(1, toTimestamp("1920a.d.", "YYYYb.c.").get(ChronoField.ERA));
- assertEquals(1, toTimestamp("1920a.d.", "YYYYa.d.").get(ChronoField.ERA));
+ assertThat(toTimestamp("1920BC", "YYYYBC").get(ChronoField.ERA), is(0));
+ assertThat(toTimestamp("1920BC", "YYYYAD").get(ChronoField.ERA), is(0));
+ assertThat(toTimestamp("1920AD", "YYYYBC").get(ChronoField.ERA), is(1));
+ assertThat(toTimestamp("1920AD", "YYYYAD").get(ChronoField.ERA), is(1));
+ assertThat(toTimestamp("1920B.C.", "YYYYB.C.").get(ChronoField.ERA), is(0));
+ assertThat(toTimestamp("1920B.C.", "YYYYA.D.").get(ChronoField.ERA), is(0));
+ assertThat(toTimestamp("1920A.D.", "YYYYB.C.").get(ChronoField.ERA), is(1));
+ assertThat(toTimestamp("1920A.D.", "YYYYA.D.").get(ChronoField.ERA), is(1));
+ assertThat(toTimestamp("1920bc", "YYYYbc").get(ChronoField.ERA), is(0));
+ assertThat(toTimestamp("1920bc", "YYYYad").get(ChronoField.ERA), is(0));
+ assertThat(toTimestamp("1920ad", "YYYYbc").get(ChronoField.ERA), is(1));
+ assertThat(toTimestamp("1920ad", "YYYYad").get(ChronoField.ERA), is(1));
+ assertThat(toTimestamp("1920b.c.", "YYYYb.c.").get(ChronoField.ERA), is(0));
+ assertThat(toTimestamp("1920b.c.", "YYYYa.d.").get(ChronoField.ERA), is(0));
+ assertThat(toTimestamp("1920a.d.", "YYYYb.c.").get(ChronoField.ERA), is(1));
+ assertThat(toTimestamp("1920a.d.", "YYYYa.d.").get(ChronoField.ERA), is(1));
}
@Test void testToTimestampMonthUpperCase() throws Exception {
- assertEquals(DAY_1_CE, toTimestamp("JANUARY", "MONTH"));
- assertEquals(DAY_1_CE.plusMonths(2), toTimestamp("MARCH", "MONTH"));
- assertEquals(DAY_1_CE.plusMonths(10), toTimestamp("NOVEMBER", "MONTH"));
+ assertThat(toTimestamp("JANUARY", "MONTH"), is(DAY_1_CE));
+ assertThat(toTimestamp("MARCH", "MONTH"), is(DAY_1_CE.plusMonths(2)));
+ assertThat(toTimestamp("NOVEMBER", "MONTH"), is(DAY_1_CE.plusMonths(10)));
}
@Test void testToTimestampMonthCapitalized() throws Exception {
- assertEquals(DAY_1_CE, toTimestamp("January", "Month"));
- assertEquals(DAY_1_CE.plusMonths(2), toTimestamp("March", "Month"));
- assertEquals(DAY_1_CE.plusMonths(10), toTimestamp("November", "Month"));
+ assertThat(toTimestamp("January", "Month"), is(DAY_1_CE));
+ assertThat(toTimestamp("March", "Month"), is(DAY_1_CE.plusMonths(2)));
+ assertThat(toTimestamp("November", "Month"), is(DAY_1_CE.plusMonths(10)));
}
@Test void testToTimestampMonthLowerCase() throws Exception {
- assertEquals(DAY_1_CE, toTimestamp("january", "month"));
- assertEquals(DAY_1_CE.plusMonths(2), toTimestamp("march", "month"));
- assertEquals(DAY_1_CE.plusMonths(10), toTimestamp("november", "month"));
+ assertThat(toTimestamp("january", "month"), is(DAY_1_CE));
+ assertThat(toTimestamp("march", "month"), is(DAY_1_CE.plusMonths(2)));
+ assertThat(toTimestamp("november", "month"), is(DAY_1_CE.plusMonths(10)));
}
@Test void testToTimestampMonUpperCase() throws Exception {
- assertEquals(DAY_1_CE, toTimestamp("JAN", "MON"));
- assertEquals(DAY_1_CE.plusMonths(2), toTimestamp("MAR", "MON"));
- assertEquals(DAY_1_CE.plusMonths(10), toTimestamp("NOV", "MON"));
+ assertThat(toTimestamp("JAN", "MON"), is(DAY_1_CE));
+ assertThat(toTimestamp("MAR", "MON"), is(DAY_1_CE.plusMonths(2)));
+ assertThat(toTimestamp("NOV", "MON"), is(DAY_1_CE.plusMonths(10)));
}
@Test void testToTimestampMonCapitalized() throws Exception {
- assertEquals(DAY_1_CE, toTimestamp("Jan", "Mon"));
- assertEquals(DAY_1_CE.plusMonths(2), toTimestamp("Mar", "Mon"));
- assertEquals(DAY_1_CE.plusMonths(10), toTimestamp("Nov", "Mon"));
+ assertThat(toTimestamp("Jan", "Mon"), is(DAY_1_CE));
+ assertThat(toTimestamp("Mar", "Mon"), is(DAY_1_CE.plusMonths(2)));
+ assertThat(toTimestamp("Nov", "Mon"), is(DAY_1_CE.plusMonths(10)));
}
@Test void testToTimestampMonLowerCase() throws Exception {
- assertEquals(DAY_1_CE, toTimestamp("jan", "mon"));
- assertEquals(DAY_1_CE.plusMonths(2), toTimestamp("mar", "mon"));
- assertEquals(DAY_1_CE.plusMonths(10), toTimestamp("nov", "mon"));
+ assertThat(toTimestamp("jan", "mon"), is(DAY_1_CE));
+ assertThat(toTimestamp("mar", "mon"), is(DAY_1_CE.plusMonths(2)));
+ assertThat(toTimestamp("nov", "mon"), is(DAY_1_CE.plusMonths(10)));
}
@Test void testToTimestampMM() throws Exception {
- assertEquals(DAY_1_CE, toTimestamp("01", "MM"));
- assertEquals(DAY_1_CE, toTimestamp("1", "MM"));
- assertEquals(DAY_1_CE.plusMonths(10), toTimestamp("11", "MM"));
+ assertThat(toTimestamp("01", "MM"), is(DAY_1_CE));
+ assertThat(toTimestamp("1", "MM"), is(DAY_1_CE));
+ assertThat(toTimestamp("11", "MM"), is(DAY_1_CE.plusMonths(10)));
}
@Test void testToTimestampDayUpperCase() throws Exception {
- assertEquals(
- createDateTime(1982, 6, 7, 0, 0, 0, 0), toTimestamp("1982 23 MONDAY", "IYYY IW DAY"));
- assertEquals(
- createDateTime(1982, 6, 10, 0, 0, 0, 0), toTimestamp("1982 23 THURSDAY", "IYYY IW DAY"));
- assertEquals(
- createDateTime(1982, 6, 11, 0, 0, 0, 0), toTimestamp("1982 23 FRIDAY", "IYYY IW DAY"));
+ assertThat(toTimestamp("1982 23 MONDAY", "IYYY IW DAY"),
+ is(createDateTime(1982, 6, 7, 0, 0, 0, 0)));
+ assertThat(toTimestamp("1982 23 THURSDAY", "IYYY IW DAY"),
+ is(createDateTime(1982, 6, 10, 0, 0, 0, 0)));
+ assertThat(toTimestamp("1982 23 FRIDAY", "IYYY IW DAY"),
+ is(createDateTime(1982, 6, 11, 0, 0, 0, 0)));
}
@Test void testToTimestampDayCapitalized() throws Exception {
- assertEquals(
- createDateTime(1982, 6, 7, 0, 0, 0, 0), toTimestamp("1982 23 Monday", "IYYY IW Day"));
- assertEquals(
- createDateTime(1982, 6, 10, 0, 0, 0, 0), toTimestamp("1982 23 Thursday", "IYYY IW Day"));
- assertEquals(
- createDateTime(1982, 6, 11, 0, 0, 0, 0), toTimestamp("1982 23 Friday", "IYYY IW Day"));
+ assertThat(toTimestamp("1982 23 Monday", "IYYY IW Day"),
+ is(createDateTime(1982, 6, 7, 0, 0, 0, 0)));
+ assertThat(toTimestamp("1982 23 Thursday", "IYYY IW Day"),
+ is(createDateTime(1982, 6, 10, 0, 0, 0, 0)));
+ assertThat(toTimestamp("1982 23 Friday", "IYYY IW Day"),
+ is(createDateTime(1982, 6, 11, 0, 0, 0, 0)));
}
@Test void testToTimestampDayLowerCase() throws Exception {
- assertEquals(
- createDateTime(1982, 6, 7, 0, 0, 0, 0), toTimestamp("1982 23 monday", "IYYY IW day"));
- assertEquals(
- createDateTime(1982, 6, 10, 0, 0, 0, 0), toTimestamp("1982 23 thursday", "IYYY IW day"));
- assertEquals(
- createDateTime(1982, 6, 11, 0, 0, 0, 0), toTimestamp("1982 23 friday", "IYYY IW day"));
+ assertThat(toTimestamp("1982 23 monday", "IYYY IW day"),
+ is(createDateTime(1982, 6, 7, 0, 0, 0, 0)));
+ assertThat(toTimestamp("1982 23 thursday", "IYYY IW day"),
+ is(createDateTime(1982, 6, 10, 0, 0, 0, 0)));
+ assertThat(toTimestamp("1982 23 friday", "IYYY IW day"),
+ is(createDateTime(1982, 6, 11, 0, 0, 0, 0)));
}
@Test void testToTimestampDyUpperCase() throws Exception {
- assertEquals(
- createDateTime(1982, 6, 7, 0, 0, 0, 0), toTimestamp("1982 23 MON", "IYYY IW DY"));
- assertEquals(
- createDateTime(1982, 6, 10, 0, 0, 0, 0), toTimestamp("1982 23 THU", "IYYY IW DY"));
- assertEquals(
- createDateTime(1982, 6, 11, 0, 0, 0, 0), toTimestamp("1982 23 FRI", "IYYY IW DY"));
+ assertThat(toTimestamp("1982 23 MON", "IYYY IW DY"),
+ is(createDateTime(1982, 6, 7, 0, 0, 0, 0)));
+ assertThat(toTimestamp("1982 23 THU", "IYYY IW DY"),
+ is(createDateTime(1982, 6, 10, 0, 0, 0, 0)));
+ assertThat(toTimestamp("1982 23 FRI", "IYYY IW DY"),
+ is(createDateTime(1982, 6, 11, 0, 0, 0, 0)));
}
@Test void testToTimestampDyCapitalized() throws Exception {
- assertEquals(
- createDateTime(1982, 6, 7, 0, 0, 0, 0), toTimestamp("1982 23 Mon", "IYYY IW Dy"));
- assertEquals(
- createDateTime(1982, 6, 10, 0, 0, 0, 0), toTimestamp("1982 23 Thu", "IYYY IW Dy"));
- assertEquals(
- createDateTime(1982, 6, 11, 0, 0, 0, 0), toTimestamp("1982 23 Fri", "IYYY IW Dy"));
+ assertThat(toTimestamp("1982 23 Mon", "IYYY IW Dy"),
+ is(createDateTime(1982, 6, 7, 0, 0, 0, 0)));
+ assertThat(toTimestamp("1982 23 Thu", "IYYY IW Dy"),
+ is(createDateTime(1982, 6, 10, 0, 0, 0, 0)));
+ assertThat(toTimestamp("1982 23 Fri", "IYYY IW Dy"),
+ is(createDateTime(1982, 6, 11, 0, 0, 0, 0)));
}
@Test void testToTimestampDyLowerCase() throws Exception {
- assertEquals(
- createDateTime(1982, 6, 7, 0, 0, 0, 0), toTimestamp("1982 23 mon", "IYYY IW dy"));
- assertEquals(
- createDateTime(1982, 6, 10, 0, 0, 0, 0), toTimestamp("1982 23 thu", "IYYY IW dy"));
- assertEquals(
- createDateTime(1982, 6, 11, 0, 0, 0, 0), toTimestamp("1982 23 fri", "IYYY IW dy"));
+ assertThat(toTimestamp("1982 23 mon", "IYYY IW dy"),
+ is(createDateTime(1982, 6, 7, 0, 0, 0, 0)));
+ assertThat(toTimestamp("1982 23 thu", "IYYY IW dy"),
+ is(createDateTime(1982, 6, 10, 0, 0, 0, 0)));
+ assertThat(toTimestamp("1982 23 fri", "IYYY IW dy"),
+ is(createDateTime(1982, 6, 11, 0, 0, 0, 0)));
}
@Test void testToTimestampDDD() throws Exception {
- assertEquals(JAN_1_2024, toTimestamp("2024 001", "YYYY DDD"));
- assertEquals(JAN_1_2024, toTimestamp("2024 1", "YYYY DDD"));
- assertEquals(createDateTime(2024, 5, 16, 0, 0, 0, 0), toTimestamp("2024 137", "YYYY DDD"));
+ assertThat(toTimestamp("2024 001", "YYYY DDD"), is(JAN_1_2024));
+ assertThat(toTimestamp("2024 1", "YYYY DDD"), is(JAN_1_2024));
+ assertThat(toTimestamp("2024 137", "YYYY DDD"),
+ is(createDateTime(2024, 5, 16, 0, 0, 0, 0)));
}
@Test void testToTimestampDD() throws Exception {
- assertEquals(DAY_1_CE, toTimestamp("01", "DD"));
- assertEquals(DAY_1_CE, toTimestamp("1", "DD"));
- assertEquals(DAY_1_CE.plusDays(22), toTimestamp("23", "DD"));
+ assertThat(toTimestamp("01", "DD"), is(DAY_1_CE));
+ assertThat(toTimestamp("1", "DD"), is(DAY_1_CE));
+ assertThat(toTimestamp("23", "DD"), is(DAY_1_CE.plusDays(22)));
}
@Test void testToTimestampIDDD() throws Exception {
- assertEquals(createDateTime(2019, 12, 30, 0, 0, 0, 0), toTimestamp("2020 001", "IYYY IDDD"));
- assertEquals(createDateTime(2019, 12, 30, 0, 0, 0, 0), toTimestamp("2020 1", "IYYY IDDD"));
- assertEquals(createDateTime(2020, 5, 14, 0, 0, 0, 0), toTimestamp("2020 137", "IYYY IDDD"));
+ assertThat(toTimestamp("2020 001", "IYYY IDDD"),
+ is(createDateTime(2019, 12, 30, 0, 0, 0, 0)));
+ assertThat(toTimestamp("2020 1", "IYYY IDDD"),
+ is(createDateTime(2019, 12, 30, 0, 0, 0, 0)));
+ assertThat(toTimestamp("2020 137", "IYYY IDDD"),
+ is(createDateTime(2020, 5, 14, 0, 0, 0, 0)));
}
@Test void testToTimestampID() throws Exception {
- assertEquals(createDateTime(1982, 6, 7, 0, 0, 0, 0), toTimestamp("1982 23 1", "IYYY IW ID"));
- assertEquals(createDateTime(1982, 6, 10, 0, 0, 0, 0), toTimestamp("1982 23 4", "IYYY IW ID"));
- assertEquals(createDateTime(1982, 6, 11, 0, 0, 0, 0), toTimestamp("1982 23 5", "IYYY IW ID"));
+ assertThat(toTimestamp("1982 23 1", "IYYY IW ID"),
+ is(createDateTime(1982, 6, 7, 0, 0, 0, 0)));
+ assertThat(toTimestamp("1982 23 4", "IYYY IW ID"),
+ is(createDateTime(1982, 6, 10, 0, 0, 0, 0)));
+ assertThat(toTimestamp("1982 23 5", "IYYY IW ID"),
+ is(createDateTime(1982, 6, 11, 0, 0, 0, 0)));
}
@Test void testToTimestampW() throws Exception {
- assertEquals(JAN_1_2024, toTimestamp("2024 1 1", "YYYY MM W"));
- assertEquals(createDateTime(2024, 4, 8, 0, 0, 0, 0), toTimestamp("2024 4 2", "YYYY MM W"));
- assertEquals(createDateTime(2024, 11, 22, 0, 0, 0, 0), toTimestamp("2024 11 4", "YYYY MM W"));
+ assertThat(toTimestamp("2024 1 1", "YYYY MM W"), is(JAN_1_2024));
+ assertThat(toTimestamp("2024 4 2", "YYYY MM W"),
+ is(createDateTime(2024, 4, 8, 0, 0, 0, 0)));
+ assertThat(toTimestamp("2024 11 4", "YYYY MM W"),
+ is(createDateTime(2024, 11, 22, 0, 0, 0, 0)));
}
@Test void testToTimestampWW() throws Exception {
- assertEquals(JAN_1_2024, toTimestamp("2024 01", "YYYY WW"));
- assertEquals(JAN_1_2024, toTimestamp("2024 1", "YYYY WW"));
- assertEquals(createDateTime(2024, 12, 16, 0, 0, 0, 0), toTimestamp("2024 51", "YYYY WW"));
+ assertThat(toTimestamp("2024 01", "YYYY WW"), is(JAN_1_2024));
+ assertThat(toTimestamp("2024 1", "YYYY WW"), is(JAN_1_2024));
+ assertThat(toTimestamp("2024 51", "YYYY WW"),
+ is(createDateTime(2024, 12, 16, 0, 0, 0, 0)));
}
@Test void testToTimestampIW() throws Exception {
- assertEquals(createDateTime(2019, 12, 30, 0, 0, 0, 0), toTimestamp("2020 01", "IYYY IW"));
- assertEquals(createDateTime(2019, 12, 30, 0, 0, 0, 0), toTimestamp("2020 1", "IYYY IW"));
- assertEquals(createDateTime(2020, 12, 14, 0, 0, 0, 0), toTimestamp("2020 51", "IYYY IW"));
+ assertThat(toTimestamp("2020 01", "IYYY IW"),
+ is(createDateTime(2019, 12, 30, 0, 0, 0, 0)));
+ assertThat(toTimestamp("2020 1", "IYYY IW"),
+ is(createDateTime(2019, 12, 30, 0, 0, 0, 0)));
+ assertThat(toTimestamp("2020 51", "IYYY IW"),
+ is(createDateTime(2020, 12, 14, 0, 0, 0, 0)));
}
@Test void testToTimestampCC() throws Exception {
- assertEquals(JAN_1_2001, toTimestamp("21", "CC"));
- assertEquals(createDateTime(1501, 1, 1, 0, 0, 0, 0), toTimestamp("16", "CC"));
- assertEquals(DAY_1_CE, toTimestamp("1", "CC"));
+ assertThat(toTimestamp("21", "CC"), is(JAN_1_2001));
+ assertThat(toTimestamp("16", "CC"), is(createDateTime(1501, 1, 1, 0, 0, 0, 0)));
+ assertThat(toTimestamp("1", "CC"), is(DAY_1_CE));
}
@Test void testToTimestampJ() throws Exception {
- assertEquals(JAN_1_2024, toTimestamp("2460311", "J"));
- assertEquals(createDateTime(1984, 7, 15, 0, 0, 0, 0), toTimestamp("2445897", "J"));
- assertEquals(createDateTime(234, 3, 21, 0, 0, 0, 0), toTimestamp("1806606", "J"));
+ assertThat(toTimestamp("2460311", "J"), is(JAN_1_2024));
+ assertThat(toTimestamp("2445897", "J"),
+ is(createDateTime(1984, 7, 15, 0, 0, 0, 0)));
+ assertThat(toTimestamp("1806606", "J"),
+ is(createDateTime(234, 3, 21, 0, 0, 0, 0)));
}
@Test void testToTimestampRMUpperCase() throws Exception {
- assertEquals(DAY_1_CE, toTimestamp("I", "RM"));
- assertEquals(DAY_1_CE.plusMonths(3), toTimestamp("IV", "RM"));
- assertEquals(DAY_1_CE.plusMonths(8), toTimestamp("IX", "RM"));
+ assertThat(toTimestamp("I", "RM"), is(DAY_1_CE));
+ assertThat(toTimestamp("IV", "RM"), is(DAY_1_CE.plusMonths(3)));
+ assertThat(toTimestamp("IX", "RM"), is(DAY_1_CE.plusMonths(8)));
}
@Test void testToTimestampRMLowerCase() throws Exception {
- assertEquals(DAY_1_CE, toTimestamp("i", "rm"));
- assertEquals(DAY_1_CE.plusMonths(3), toTimestamp("iv", "rm"));
- assertEquals(DAY_1_CE.plusMonths(8), toTimestamp("ix", "rm"));
+ assertThat(toTimestamp("i", "rm"), is(DAY_1_CE));
+ assertThat(toTimestamp("iv", "rm"), is(DAY_1_CE.plusMonths(3)));
+ assertThat(toTimestamp("ix", "rm"), is(DAY_1_CE.plusMonths(8)));
}
@Test void testToTimestampDateValidFormats() throws Exception {
- assertEquals(APR_17_2024, toTimestamp("2024-04-17", "YYYY-MM-DD"));
- assertEquals(APR_17_2024, toTimestamp("2,024-04-17", "Y,YYY-MM-DD"));
- assertEquals(APR_17_2024, toTimestamp("24-04-17", "YYY-MM-DD"));
- assertEquals(APR_17_2024, toTimestamp("24-04-17", "YY-MM-DD"));
- assertEquals(APR_17_2024, toTimestamp("2124-04-17", "CCYY-MM-DD"));
- assertEquals(APR_17_2024, toTimestamp("20240417", "YYYYMMDD"));
- assertEquals(APR_17_2024, toTimestamp("2,0240417", "Y,YYYMMDD"));
- assertEquals(APR_17_2024, toTimestamp("2024-16-3", "IYYY-IW-ID"));
- assertEquals(APR_17_2024, toTimestamp("2024-16 Wednesday", "IYYY-IW Day"));
- assertEquals(APR_17_2024, toTimestamp("2024-108", "IYYY-IDDD"));
- assertEquals(APR_17_2024, toTimestamp("April 17, 2024", "Month DD, YYYY"));
- assertEquals(APR_17_2024, toTimestamp("IV 17, 2024", "RM DD, YYYY"));
- assertEquals(APR_17_2024, toTimestamp("APR 17, 2024", "MON DD, YYYY"));
- assertEquals(createDateTime(2024, 4, 15, 0, 0, 0, 0), toTimestamp("2024-16", "YYYY-WW"));
- assertEquals(APR_17_2024, toTimestamp("2024-108", "YYYY-DDD"));
- assertEquals(DAY_1_CE, toTimestamp("0000-01-01", "YYYY-MM-DD"));
+ assertThat(toTimestamp("2024-04-17", "YYYY-MM-DD"), is(APR_17_2024));
+ assertThat(toTimestamp("2,024-04-17", "Y,YYY-MM-DD"), is(APR_17_2024));
+ assertThat(toTimestamp("24-04-17", "YYY-MM-DD"), is(APR_17_2024));
+ assertThat(toTimestamp("24-04-17", "YY-MM-DD"), is(APR_17_2024));
+ assertThat(toTimestamp("2124-04-17", "CCYY-MM-DD"), is(APR_17_2024));
+ assertThat(toTimestamp("20240417", "YYYYMMDD"), is(APR_17_2024));
+ assertThat(toTimestamp("2,0240417", "Y,YYYMMDD"), is(APR_17_2024));
+ assertThat(toTimestamp("2024-16-3", "IYYY-IW-ID"), is(APR_17_2024));
+ assertThat(toTimestamp("2024-16 Wednesday", "IYYY-IW Day"), is(APR_17_2024));
+ assertThat(toTimestamp("2024-108", "IYYY-IDDD"), is(APR_17_2024));
+ assertThat(toTimestamp("April 17, 2024", "Month DD, YYYY"), is(APR_17_2024));
+ assertThat(toTimestamp("IV 17, 2024", "RM DD, YYYY"), is(APR_17_2024));
+ assertThat(toTimestamp("APR 17, 2024", "MON DD, YYYY"), is(APR_17_2024));
+ assertThat(toTimestamp("2024-16", "YYYY-WW"),
+ is(createDateTime(2024, 4, 15, 0, 0, 0, 0)));
+ assertThat(toTimestamp("2024-108", "YYYY-DDD"), is(APR_17_2024));
+ assertThat(toTimestamp("0000-01-01", "YYYY-MM-DD"), is(DAY_1_CE));
}
@Test void testToTimestampWithTimezone() throws Exception {
final ZoneId utcZone = ZoneId.of("UTC");
- assertEquals(
- APR_17_2024.plusHours(7).withZoneSameLocal(utcZone),
+ assertThat(
PostgresqlDateTimeFormatter.toTimestamp("2024-04-17 00:00:00-07:00",
- "YYYY-MM-DD HH24:MI:SSTZH:TZM", utcZone, Locale.US));
+ "YYYY-MM-DD HH24:MI:SSTZH:TZM", utcZone, Locale.US),
+ is(APR_17_2024.plusHours(7).withZoneSameLocal(utcZone)));
}
protected static ZonedDateTime createDateTime(int year, int month, int dayOfMonth, int hour,
diff --git a/core/src/test/java/org/apache/calcite/util/mapping/MappingTest.java b/core/src/test/java/org/apache/calcite/util/mapping/MappingTest.java
index 9657992901..ab78e9b333 100644
--- a/core/src/test/java/org/apache/calcite/util/mapping/MappingTest.java
+++ b/core/src/test/java/org/apache/calcite/util/mapping/MappingTest.java
@@ -30,7 +30,6 @@ import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.hasToString;
-import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -89,22 +88,17 @@ class MappingTest {
* Unit test for {@link Mappings#createShiftMapping}.
*/
@Test void testMappingsCreateShiftMapping() {
- assertEquals(
- "[size=5, sourceCount=20, targetCount=13, elements=[6:3, 7:4, 15:10, 16:11, 17:12]]",
- Mappings.createShiftMapping(
- 20,
- 3, 6, 2,
- 10, 15, 3).toString());
+ assertThat(Mappings.createShiftMapping(20, 3, 6, 2, 10, 15, 3),
+ hasToString("[size=5, sourceCount=20, targetCount=13, "
+ + "elements=[6:3, 7:4, 15:10, 16:11, 17:12]]"));
// no triples makes for a mapping with 0 targets, 20 sources, but still
// valid
- Mappings.TargetMapping mapping =
- Mappings.createShiftMapping(
- 20);
- assertEquals("[size=0, sourceCount=20, targetCount=0, elements=[]]",
- mapping.toString());
- assertEquals(20, mapping.getSourceCount());
- assertEquals(0, mapping.getTargetCount());
+ Mappings.TargetMapping mapping = Mappings.createShiftMapping(20);
+ assertThat(mapping,
+ hasToString("[size=0, sourceCount=20, targetCount=0, elements=[]]"));
+ assertThat(mapping.getSourceCount(), is(20));
+ assertThat(mapping.getTargetCount(), is(0));
}
/**
@@ -120,9 +114,8 @@ class MappingTest {
mapping0.set(0, 2);
mapping0.set(3, 1);
mapping0.set(4, 0);
- assertEquals(
- "[size=5, sourceCount=7, targetCount=5, elements=[0:2, 3:1, 4:0, 5:3, 6:4]]",
- Mappings.append(mapping0, Mappings.createIdentity(2)).toString());
+ assertThat(Mappings.append(mapping0, Mappings.createIdentity(2)),
+ hasToString("[size=5, sourceCount=7, targetCount=5, elements=[0:2, 3:1, 4:0, 5:3, 6:4]]"));
}
/**
@@ -131,28 +124,27 @@ class MappingTest {
@Test void testMappingsOffsetSource() {
final Mappings.TargetMapping mapping =
Mappings.target(ImmutableMap.of(0, 5, 1, 7), 2, 8);
- assertEquals(
- "[size=2, sourceCount=2, targetCount=8, elements=[0:5, 1:7]]",
- mapping.toString());
- assertEquals(2, mapping.getSourceCount());
- assertEquals(8, mapping.getTargetCount());
+ assertThat(mapping,
+ hasToString("[size=2, sourceCount=2, targetCount=8, elements=[0:5, 1:7]]"));
+ assertThat(mapping.getSourceCount(), is(2));
+ assertThat(mapping.getTargetCount(), is(8));
final Mappings.TargetMapping mapping1 =
Mappings.offsetSource(mapping, 3, 5);
- assertEquals(
- "[size=2, sourceCount=5, targetCount=8, elements=[3:5, 4:7]]",
- mapping1.toString());
- assertEquals(5, mapping1.getSourceCount());
- assertEquals(8, mapping1.getTargetCount());
+ assertThat(mapping1,
+ hasToString("[size=2, sourceCount=5, targetCount=8, "
+ + "elements=[3:5, 4:7]]"));
+ assertThat(mapping1.getSourceCount(), is(5));
+ assertThat(mapping1.getTargetCount(), is(8));
// mapping that extends RHS
final Mappings.TargetMapping mapping2 =
Mappings.offsetSource(mapping, 3, 15);
- assertEquals(
- "[size=2, sourceCount=15, targetCount=8, elements=[3:5, 4:7]]",
- mapping2.toString());
- assertEquals(15, mapping2.getSourceCount());
- assertEquals(8, mapping2.getTargetCount());
+ assertThat(mapping2,
+ hasToString("[size=2, sourceCount=15, targetCount=8, "
+ + "elements=[3:5, 4:7]]"));
+ assertThat(mapping2.getSourceCount(), is(15));
+ assertThat(mapping2.getTargetCount(), is(8));
assertThrows(IllegalArgumentException.class, () -> Mappings.offsetSource(mapping, 3, 4));
}
@@ -183,7 +175,8 @@ class MappingTest {
final Mapping inverse = mapping.inverse();
assertThat(inverse,
hasToString(
- "[size=5, sourceCount=10, targetCount=5, elements=[1:1, 3:0, 4:2, 5:3, 8:4]]"));
+ "[size=5, sourceCount=10, targetCount=5, "
+ + "elements=[1:1, 3:0, 4:2, 5:3, 8:4]]"));
}
/** Unit test for {@link Mappings#target(List, int)}. */
diff --git a/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchJsonTest.java b/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchJsonTest.java
index 5ee45c86a5..757c52aa60 100644
--- a/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchJsonTest.java
+++ b/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchJsonTest.java
@@ -37,7 +37,6 @@ import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.aMapWithSize;
import static org.hamcrest.Matchers.anEmptyMap;
import static org.hamcrest.Matchers.hasSize;
-import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
/**
@@ -68,11 +67,12 @@ class ElasticsearchJsonTest {
ElasticsearchJson.Aggregations a = mapper.readValue(json, ElasticsearchJson.Aggregations.class);
assertNotNull(a);
- assertEquals(1, a.asList().size());
- assertEquals(1, a.asMap().size());
- assertEquals("agg1", a.asList().get(0).getName());
- assertEquals("agg1", a.asMap().keySet().iterator().next());
- assertEquals("111", ((ElasticsearchJson.MultiValue) a.asList().get(0)).value());
+ assertThat(a.asList(), hasSize(1));
+ assertThat(a.asMap(), aMapWithSize(1));
+ assertThat(a.asList().get(0).getName(), is("agg1"));
+ assertThat(a.asMap().keySet().iterator().next(), is("agg1"));
+ assertThat(((ElasticsearchJson.MultiValue) a.asList().get(0)).value(),
+ is("111"));
List<Map<String, Object>> rows = new ArrayList<>();
ElasticsearchJson.visitValueNodes(a, rows::add);
@@ -84,9 +84,9 @@ class ElasticsearchJsonTest {
String json = "{ agg1: {min: 0, max: 2, avg: 2.33}}";
ElasticsearchJson.Aggregations a = mapper.readValue(json, ElasticsearchJson.Aggregations.class);
assertNotNull(a);
- assertEquals(1, a.asList().size());
- assertEquals(1, a.asMap().size());
- assertEquals("agg1", a.asList().get(0).getName());
+ assertThat(a.asList(), hasSize(1));
+ assertThat(a.asMap(), aMapWithSize(1));
+ assertThat(a.asList().get(0).getName(), is("agg1"));
Map<String, Object> values = ((ElasticsearchJson.MultiValue) a.get("agg1")).values();
assertThat(values.keySet(), hasItems("min", "max", "avg"));
@@ -97,8 +97,8 @@ class ElasticsearchJsonTest {
ElasticsearchJson.Aggregations a = mapper.readValue(json, ElasticsearchJson.Aggregations.class);
assertNotNull(a);
- assertEquals(2, a.asList().size());
- assertEquals(2, a.asMap().size());
+ assertThat(a.asList(), hasSize(2));
+ assertThat(a.asMap(), aMapWithSize(2));
assertThat(a.asMap().keySet(), hasItems("agg1", "agg2"));
}
@@ -106,10 +106,12 @@ class ElasticsearchJsonTest {
String json = "{ groupby: {buckets: [{key:'k1', doc_count:0, myagg:{value: 1.1}},"
+ " {key:'k2', myagg:{value: 2.2}}] }}";
- ElasticsearchJson.Aggregations a = mapper.readValue(json, ElasticsearchJson.Aggregations.class);
+ ElasticsearchJson.Aggregations a =
+ mapper.readValue(json, ElasticsearchJson.Aggregations.class);
assertThat(a.asMap().keySet(), hasItem("groupby"));
- assertThat(a.get("groupby"), instanceOf(ElasticsearchJson.MultiBucketsAggregation.class));
+ assertThat(a.get("groupby"),
+ instanceOf(ElasticsearchJson.MultiBucketsAggregation.class));
ElasticsearchJson.MultiBucketsAggregation multi = a.get("groupby");
assertThat(multi.buckets(), hasSize(2));
assertThat(multi.getName(), is("groupby"));
@@ -159,7 +161,8 @@ class ElasticsearchJsonTest {
assertNotNull(a);
assertThat(a.asMap().keySet(), hasItem("col1"));
- assertThat(a.get("col1"), instanceOf(ElasticsearchJson.MultiBucketsAggregation.class));
+ assertThat(a.get("col1"),
+ instanceOf(ElasticsearchJson.MultiBucketsAggregation.class));
ElasticsearchJson.MultiBucketsAggregation m = a.get("col1");
assertThat(m.getName(), is("col1"));
assertThat(m.buckets(), hasSize(2));
@@ -184,7 +187,7 @@ class ElasticsearchJsonTest {
/**
* Validate that property names which are reserved keywords ES
- * are correctly mapped (eg. {@code type} or {@code properties})
+ * are correctly mapped (e.g. {@code type} or {@code properties})
*/
@Test void reservedKeywordMapping() throws Exception {
// have special property names: type and properties
diff --git a/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchVersionTest.java b/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchVersionTest.java
index 1e5485c1f2..be8c3a1501 100644
--- a/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchVersionTest.java
+++ b/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchVersionTest.java
@@ -20,7 +20,10 @@ import org.junit.jupiter.api.Test;
import java.util.Locale;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.apache.calcite.adapter.elasticsearch.ElasticsearchVersion.fromString;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.fail;
/**
@@ -29,13 +32,13 @@ import static org.junit.jupiter.api.Assertions.fail;
class ElasticsearchVersionTest {
@Test void versions() {
- assertEquals(ElasticsearchVersion.fromString("2.3.4"), ElasticsearchVersion.ES2);
- assertEquals(ElasticsearchVersion.fromString("2.0.0"), ElasticsearchVersion.ES2);
- assertEquals(ElasticsearchVersion.fromString("5.6.1"), ElasticsearchVersion.ES5);
- assertEquals(ElasticsearchVersion.fromString("6.0.1"), ElasticsearchVersion.ES6);
- assertEquals(ElasticsearchVersion.fromString("7.0.1"), ElasticsearchVersion.ES7);
- assertEquals(ElasticsearchVersion.fromString("111.0.1"), ElasticsearchVersion.UNKNOWN);
- assertEquals(ElasticsearchVersion.fromString("2020.12.12"), ElasticsearchVersion.UNKNOWN);
+ assertThat(ElasticsearchVersion.ES2, is(fromString("2.3.4")));
+ assertThat(ElasticsearchVersion.ES2, is(fromString("2.0.0")));
+ assertThat(ElasticsearchVersion.ES5, is(fromString("5.6.1")));
+ assertThat(ElasticsearchVersion.ES6, is(fromString("6.0.1")));
+ assertThat(ElasticsearchVersion.ES7, is(fromString("7.0.1")));
+ assertThat(ElasticsearchVersion.UNKNOWN, is(fromString("111.0.1")));
+ assertThat(ElasticsearchVersion.UNKNOWN, is(fromString("2020.12.12")));
assertFails("");
assertFails(".");
@@ -54,7 +57,7 @@ class ElasticsearchVersionTest {
private static void assertFails(String version) {
try {
- ElasticsearchVersion.fromString(version);
+ fromString(version);
fail(String.format(Locale.ROOT, "Should fail for version %s", version));
} catch (IllegalArgumentException ignore) {
// expected
diff --git a/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/Projection2Test.java b/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/Projection2Test.java
index c79ad24459..388d5c95a3 100644
--- a/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/Projection2Test.java
+++ b/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/Projection2Test.java
@@ -43,7 +43,8 @@ import java.util.Map;
import java.util.function.Consumer;
import java.util.regex.PatternSyntaxException;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.hasToString;
import static org.junit.jupiter.api.Assertions.fail;
/**
@@ -295,7 +296,7 @@ class Projection2Test {
fail &= processedRows == lines.length;
if (fail) {
- assertEquals(String.join("\n", Arrays.asList(lines)), actual.toString());
+ assertThat(actual, hasToString(String.join("\n", lines)));
fail("Should have failed on previous line, but for some reason didn't");
}
} catch (SQLException e) {
diff --git a/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/QueryBuildersTest.java b/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/QueryBuildersTest.java
index 5e80326fd7..9264be0a5c 100644
--- a/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/QueryBuildersTest.java
+++ b/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/QueryBuildersTest.java
@@ -16,9 +16,14 @@
*/
package org.apache.calcite.adapter.elasticsearch;
+import org.apache.calcite.test.Unsafe;
+
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.ObjectMapper;
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.hamcrest.TypeSafeMatcher;
import org.junit.jupiter.api.Test;
import java.io.IOException;
@@ -31,7 +36,15 @@ import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.apache.calcite.adapter.elasticsearch.QueryBuilders.boolQuery;
+import static org.apache.calcite.adapter.elasticsearch.QueryBuilders.matchesQuery;
+import static org.apache.calcite.adapter.elasticsearch.QueryBuilders.rangeQuery;
+import static org.apache.calcite.adapter.elasticsearch.QueryBuilders.termQuery;
+import static org.apache.calcite.adapter.elasticsearch.QueryBuilders.termsQuery;
+import static org.apache.calcite.adapter.elasticsearch.QueryBuildersTest.JsonMatcher.hasJson;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
/**
* Check that internal queries are correctly converted to ES search query (as
@@ -39,149 +52,171 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
*/
class QueryBuildersTest {
- private final ObjectMapper mapper = new ObjectMapper();
-
/**
* Test for simple scalar terms (boolean, int etc.)
*
- * @throws Exception not expected
*/
- @Test void term() throws Exception {
- assertEquals("{\"term\":{\"foo\":\"bar\"}}",
- toJson(QueryBuilders.termQuery("foo", "bar")));
- assertEquals("{\"term\":{\"bar\":\"foo\"}}",
- toJson(QueryBuilders.termQuery("bar", "foo")));
- assertEquals("{\"term\":{\"foo\":\"A\"}}",
- toJson(QueryBuilders.termQuery("foo", 'A')));
- assertEquals("{\"term\":{\"foo\":true}}",
- toJson(QueryBuilders.termQuery("foo", true)));
- assertEquals("{\"term\":{\"foo\":false}}",
- toJson(QueryBuilders.termQuery("foo", false)));
- assertEquals("{\"term\":{\"foo\":0}}",
- toJson(QueryBuilders.termQuery("foo", (byte) 0)));
- assertEquals("{\"term\":{\"foo\":123}}",
- toJson(QueryBuilders.termQuery("foo", (long) 123)));
- assertEquals("{\"term\":{\"foo\":41}}",
- toJson(QueryBuilders.termQuery("foo", (short) 41)));
- assertEquals("{\"term\":{\"foo\":42.42}}",
- toJson(QueryBuilders.termQuery("foo", 42.42D)));
- assertEquals("{\"term\":{\"foo\":1.1}}",
- toJson(QueryBuilders.termQuery("foo", 1.1F)));
- assertEquals("{\"term\":{\"foo\":1}}",
- toJson(QueryBuilders.termQuery("foo", new BigDecimal(1))));
- assertEquals("{\"term\":{\"foo\":121}}",
- toJson(QueryBuilders.termQuery("foo", new BigInteger("121"))));
- assertEquals("{\"term\":{\"foo\":111}}",
- toJson(QueryBuilders.termQuery("foo", new AtomicLong(111))));
- assertEquals("{\"term\":{\"foo\":222}}",
- toJson(QueryBuilders.termQuery("foo", new AtomicInteger(222))));
- assertEquals("{\"term\":{\"foo\":true}}",
- toJson(QueryBuilders.termQuery("foo", new AtomicBoolean(true))));
+ @Test void term() {
+ assertThat(termQuery("foo", "bar"),
+ hasJson("{\"term\":{\"foo\":\"bar\"}}"));
+ assertThat(termQuery("bar", "foo"),
+ hasJson("{\"term\":{\"bar\":\"foo\"}}"));
+ assertThat(termQuery("foo", 'A'),
+ hasJson("{\"term\":{\"foo\":\"A\"}}"));
+ assertThat(termQuery("foo", true),
+ hasJson("{\"term\":{\"foo\":true}}"));
+ assertThat(termQuery("foo", false),
+ hasJson("{\"term\":{\"foo\":false}}"));
+ assertThat(termQuery("foo", (byte) 0),
+ hasJson("{\"term\":{\"foo\":0}}"));
+ assertThat(termQuery("foo", (long) 123),
+ hasJson("{\"term\":{\"foo\":123}}"));
+ assertThat(termQuery("foo", (short) 41),
+ hasJson("{\"term\":{\"foo\":41}}"));
+ assertThat(termQuery("foo", 42.42D),
+ hasJson("{\"term\":{\"foo\":42.42}}"));
+ assertThat(termQuery("foo", 1.1F),
+ hasJson("{\"term\":{\"foo\":1.1}}"));
+ assertThat(termQuery("foo", new BigDecimal(1)),
+ hasJson("{\"term\":{\"foo\":1}}"));
+ assertThat(termQuery("foo", new BigInteger("121")),
+ hasJson("{\"term\":{\"foo\":121}}"));
+ assertThat(termQuery("foo", new AtomicLong(111)),
+ hasJson("{\"term\":{\"foo\":111}}"));
+ assertThat(termQuery("foo", new AtomicInteger(222)),
+ hasJson("{\"term\":{\"foo\":222}}"));
+ assertThat(termQuery("foo", new AtomicBoolean(true)),
+ hasJson("{\"term\":{\"foo\":true}}"));
}
- @Test void terms() throws Exception {
- assertEquals("{\"terms\":{\"foo\":[]}}",
- toJson(QueryBuilders.termsQuery("foo", Collections.emptyList())));
+ @Test void terms() {
+ assertThat(termsQuery("foo", Collections.emptyList()),
+ hasJson("{\"terms\":{\"foo\":[]}}"));
- assertEquals("{\"terms\":{\"bar\":[]}}",
- toJson(QueryBuilders.termsQuery("bar", Collections.emptySet())));
+ assertThat(termsQuery("bar", Collections.emptySet()),
+ hasJson("{\"terms\":{\"bar\":[]}}"));
- assertEquals("{\"terms\":{\"singleton\":[0]}}",
- toJson(QueryBuilders.termsQuery("singleton", Collections.singleton(0))));
+ assertThat(termsQuery("singleton", Collections.singleton(0)),
+ hasJson("{\"terms\":{\"singleton\":[0]}}"));
- assertEquals("{\"terms\":{\"foo\":[true]}}",
- toJson(QueryBuilders.termsQuery("foo", Collections.singleton(true))));
+ assertThat(termsQuery("foo", Collections.singleton(true)),
+ hasJson("{\"terms\":{\"foo\":[true]}}"));
- assertEquals("{\"terms\":{\"foo\":[\"bar\"]}}",
- toJson(QueryBuilders.termsQuery("foo", Collections.singleton("bar"))));
+ assertThat(termsQuery("foo", Collections.singleton("bar")),
+ hasJson("{\"terms\":{\"foo\":[\"bar\"]}}"));
- assertEquals("{\"terms\":{\"foo\":[\"bar\"]}}",
- toJson(QueryBuilders.termsQuery("foo", Collections.singletonList("bar"))));
+ assertThat(termsQuery("foo", Collections.singletonList("bar")),
+ hasJson("{\"terms\":{\"foo\":[\"bar\"]}}"));
- assertEquals("{\"terms\":{\"foo\":[true,false]}}",
- toJson(QueryBuilders.termsQuery("foo", Arrays.asList(true, false))));
+ assertThat(termsQuery("foo", Arrays.asList(true, false)),
+ hasJson("{\"terms\":{\"foo\":[true,false]}}"));
- assertEquals("{\"terms\":{\"foo\":[1,2,3]}}",
- toJson(QueryBuilders.termsQuery("foo", Arrays.asList(1, 2, 3))));
+ assertThat(termsQuery("foo", Arrays.asList(1, 2, 3)),
+ hasJson("{\"terms\":{\"foo\":[1,2,3]}}"));
- assertEquals("{\"terms\":{\"foo\":[1.1,2.2,3.3]}}",
- toJson(QueryBuilders.termsQuery("foo", Arrays.asList(1.1, 2.2, 3.3))));
+ assertThat(termsQuery("foo", Arrays.asList(1.1, 2.2, 3.3)),
+ hasJson("{\"terms\":{\"foo\":[1.1,2.2,3.3]}}"));
}
- @Test void boolQuery() throws Exception {
- QueryBuilders.QueryBuilder q1 = QueryBuilders.boolQuery()
- .must(QueryBuilders.termQuery("foo", "bar"));
-
- assertEquals("{\"bool\":{\"must\":{\"term\":{\"foo\":\"bar\"}}}}",
- toJson(q1));
-
- QueryBuilders.QueryBuilder q2 = QueryBuilders.boolQuery()
- .must(QueryBuilders.termQuery("f1", "v1")).must(QueryBuilders.termQuery("f2", "v2"));
-
- assertEquals("{\"bool\":{\"must\":[{\"term\":{\"f1\":\"v1\"}},{\"term\":{\"f2\":\"v2\"}}]}}",
- toJson(q2));
-
- QueryBuilders.QueryBuilder q3 = QueryBuilders.boolQuery()
- .mustNot(QueryBuilders.termQuery("f1", "v1"));
+ @Test void bool() {
+ assertThat(boolQuery()
+ .must(termQuery("foo", "bar")),
+ hasJson("{\"bool\":{\"must\":{\"term\":{\"foo\":\"bar\"}}}}"));
- assertEquals("{\"bool\":{\"must_not\":{\"term\":{\"f1\":\"v1\"}}}}",
- toJson(q3));
+ assertThat(boolQuery()
+ .must(termQuery("f1", "v1"))
+ .must(termQuery("f2", "v2")),
+ hasJson("{\"bool\":{\"must\":[{\"term\":{\"f1\":\"v1\"}},"
+ + "{\"term\":{\"f2\":\"v2\"}}]}}"));
+ assertThat(boolQuery()
+ .mustNot(termQuery("f1", "v1")),
+ hasJson("{\"bool\":{\"must_not\":{\"term\":{\"f1\":\"v1\"}}}}"));
}
- @Test void exists() throws Exception {
- assertEquals("{\"exists\":{\"field\":\"foo\"}}",
- toJson(QueryBuilders.existsQuery("foo")));
+ @Test void exists() {
+ assertThat(QueryBuilders.existsQuery("foo"),
+ hasJson("{\"exists\":{\"field\":\"foo\"}}"));
}
- @Test void range() throws Exception {
- assertEquals("{\"range\":{\"f\":{\"lt\":0}}}",
- toJson(QueryBuilders.rangeQuery("f").lt(0)));
- assertEquals("{\"range\":{\"f\":{\"gt\":0}}}",
- toJson(QueryBuilders.rangeQuery("f").gt(0)));
- assertEquals("{\"range\":{\"f\":{\"gte\":0}}}",
- toJson(QueryBuilders.rangeQuery("f").gte(0)));
- assertEquals("{\"range\":{\"f\":{\"lte\":0}}}",
- toJson(QueryBuilders.rangeQuery("f").lte(0)));
- assertEquals("{\"range\":{\"f\":{\"gt\":1,\"lt\":2}}}",
- toJson(QueryBuilders.rangeQuery("f").gt(1).lt(2)));
- assertEquals("{\"range\":{\"f\":{\"gt\":11,\"lt\":0}}}",
- toJson(QueryBuilders.rangeQuery("f").lt(0).gt(11)));
- assertEquals("{\"range\":{\"f\":{\"gt\":1,\"lte\":2}}}",
- toJson(QueryBuilders.rangeQuery("f").gt(1).lte(2)));
- assertEquals("{\"range\":{\"f\":{\"gte\":1,\"lte\":\"zz\"}}}",
- toJson(QueryBuilders.rangeQuery("f").gte(1).lte("zz")));
- assertEquals("{\"range\":{\"f\":{\"gte\":1}}}",
- toJson(QueryBuilders.rangeQuery("f").gte(1)));
- assertEquals("{\"range\":{\"f\":{\"gte\":\"zz\"}}}",
- toJson(QueryBuilders.rangeQuery("f").gte("zz")));
- assertEquals("{\"range\":{\"f\":{\"gt\":\"a\",\"lt\":\"z\"}}}",
- toJson(QueryBuilders.rangeQuery("f").gt("a").lt("z")));
- assertEquals("{\"range\":{\"f\":{\"gte\":3}}}",
- toJson(QueryBuilders.rangeQuery("f").gt(1).gt(2).gte(3)));
- assertEquals("{\"range\":{\"f\":{\"lte\":3}}}",
- toJson(QueryBuilders.rangeQuery("f").lt(1).lt(2).lte(3)));
+ @Test void range() {
+ assertThat(rangeQuery("f").lt(0),
+ hasJson("{\"range\":{\"f\":{\"lt\":0}}}"));
+ assertThat(rangeQuery("f").gt(0),
+ hasJson("{\"range\":{\"f\":{\"gt\":0}}}"));
+ assertThat(rangeQuery("f").gte(0),
+ hasJson("{\"range\":{\"f\":{\"gte\":0}}}"));
+ assertThat(rangeQuery("f").lte(0),
+ hasJson("{\"range\":{\"f\":{\"lte\":0}}}"));
+ assertThat(rangeQuery("f").gt(1).lt(2),
+ hasJson("{\"range\":{\"f\":{\"gt\":1,\"lt\":2}}}"));
+ assertThat(rangeQuery("f").lt(0).gt(11),
+ hasJson("{\"range\":{\"f\":{\"gt\":11,\"lt\":0}}}"));
+ assertThat(rangeQuery("f").gt(1).lte(2),
+ hasJson("{\"range\":{\"f\":{\"gt\":1,\"lte\":2}}}"));
+ assertThat(rangeQuery("f").gte(1).lte("zz"),
+ hasJson("{\"range\":{\"f\":{\"gte\":1,\"lte\":\"zz\"}}}"));
+ assertThat(rangeQuery("f").gte(1),
+ hasJson("{\"range\":{\"f\":{\"gte\":1}}}"));
+ assertThat(rangeQuery("f").gte("zz"),
+ hasJson("{\"range\":{\"f\":{\"gte\":\"zz\"}}}"));
+ assertThat(rangeQuery("f").gt("a").lt("z"),
+ hasJson("{\"range\":{\"f\":{\"gt\":\"a\",\"lt\":\"z\"}}}"));
+ assertThat(rangeQuery("f").gt(1).gt(2).gte(3),
+ hasJson("{\"range\":{\"f\":{\"gte\":3}}}"));
+ assertThat(rangeQuery("f").lt(1).lt(2).lte(3),
+ hasJson("{\"range\":{\"f\":{\"lte\":3}}}"));
}
- @Test void matchAll() throws IOException {
- assertEquals("{\"match_all\":{}}",
- toJson(QueryBuilders.matchAll()));
+ @Test void matchAll() {
+ assertThat(QueryBuilders.matchAll(),
+ hasJson("{\"match_all\":{}}"));
}
- @Test void match() throws IOException {
- assertEquals("{\"match\":{\"foo\":[\"bar\"]}}",
- toJson(QueryBuilders.matchesQuery("foo", Collections.singleton("bar"))));
+ @Test void match() {
+ assertThat(matchesQuery("foo", Collections.singleton("bar")),
+ hasJson("{\"match\":{\"foo\":[\"bar\"]}}"));
- assertEquals("{\"match\":{\"foo\":[true]}}",
- toJson(QueryBuilders.matchesQuery("foo", Collections.singleton(true))));
+ assertThat(matchesQuery("foo", Collections.singleton(true)),
+ hasJson("{\"match\":{\"foo\":[true]}}"));
}
- private String toJson(QueryBuilders.QueryBuilder builder) throws IOException {
- StringWriter writer = new StringWriter();
- JsonGenerator gen = mapper.getFactory().createGenerator(writer);
- builder.writeJson(gen);
- gen.flush();
- gen.close();
- return writer.toString();
+ /** Matcher that succeeds if a
+ * {@link org.apache.calcite.adapter.elasticsearch.QueryBuilders.QueryBuilder}
+ * yields JSON that matches a given string. */
+ static class JsonMatcher extends TypeSafeMatcher<QueryBuilders.QueryBuilder> {
+ private final Matcher<String> matcher;
+
+ protected JsonMatcher(Matcher<String> matcher) {
+ super(QueryBuilders.QueryBuilder.class);
+ this.matcher = matcher;
+ }
+
+ static Matcher<QueryBuilders.QueryBuilder> hasJson(String s) {
+ return new JsonMatcher(is(s));
+ }
+
+ private static String toJson(QueryBuilders.QueryBuilder builder,
+ ObjectMapper mapper) {
+ try {
+ StringWriter writer = new StringWriter();
+ JsonGenerator gen = mapper.getFactory().createGenerator(writer);
+ builder.writeJson(gen);
+ gen.flush();
+ gen.close();
+ return writer.toString();
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override protected boolean matchesSafely(QueryBuilders.QueryBuilder builder) {
+ final String json = toJson(builder, new ObjectMapper());
+ return Unsafe.matches(matcher, json);
+ }
+
+ @Override public void describeTo(Description description) {
+ description.appendText("json ").appendDescriptionOf(matcher);
+ }
}
}
diff --git a/elasticsearch/src/test/java/org/apache/calcite/test/ElasticsearchChecker.java b/elasticsearch/src/test/java/org/apache/calcite/test/ElasticsearchChecker.java
index 6d73343b46..abc3bb24fe 100644
--- a/elasticsearch/src/test/java/org/apache/calcite/test/ElasticsearchChecker.java
+++ b/elasticsearch/src/test/java/org/apache/calcite/test/ElasticsearchChecker.java
@@ -25,12 +25,11 @@ import com.fasterxml.jackson.databind.node.ObjectNode;
import java.io.IOException;
import java.io.UncheckedIOException;
-import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
-import java.util.stream.Collectors;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
import static java.util.Objects.requireNonNull;
@@ -62,13 +61,14 @@ public class ElasticsearchChecker {
actual = expandDots(actual);
try {
- String json = "{" + Arrays.stream(strings).collect(Collectors.joining(",")) + "}";
+ String json = "{" + String.join(",", strings) + "}";
ObjectNode expected = (ObjectNode) MAPPER.readTree(json);
expected = expandDots(expected);
if (!expected.equals(actual)) {
- assertEquals(MAPPER.writeValueAsString(expected), MAPPER.writeValueAsString(actual),
- "expected and actual Elasticsearch queries do not match");
+ assertThat("expected and actual Elasticsearch queries do not match",
+ MAPPER.writeValueAsString(actual),
+ is(MAPPER.writeValueAsString(expected)));
}
} catch (IOException e) {
throw new UncheckedIOException(e);
diff --git a/example/csv/src/test/java/org/apache/calcite/test/CsvTest.java b/example/csv/src/test/java/org/apache/calcite/test/CsvTest.java
index 52f8fefe66..dd81427ba2 100644
--- a/example/csv/src/test/java/org/apache/calcite/test/CsvTest.java
+++ b/example/csv/src/test/java/org/apache/calcite/test/CsvTest.java
@@ -59,13 +59,14 @@ import java.util.concurrent.Callable;
import java.util.function.Consumer;
import java.util.stream.Stream;
+import static org.apache.calcite.test.Matchers.isListOf;
+
import static org.hamcrest.CoreMatchers.anyOf;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.isA;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.fail;
import static java.sql.Timestamp.valueOf;
@@ -433,7 +434,7 @@ class CsvTest {
try {
final List<String> lines = new ArrayList<>();
CsvTest.collect(lines, resultSet);
- assertEquals(Arrays.asList(expected), lines);
+ assertThat(lines, isListOf(expected));
} catch (SQLException e) {
throw TestUtil.rethrow(e);
}
@@ -450,7 +451,7 @@ class CsvTest {
final List<String> lines = new ArrayList<>();
CsvTest.collect(lines, resultSet);
Collections.sort(lines);
- assertEquals(expectedLines, lines);
+ assertThat(lines, is(expectedLines));
} catch (SQLException e) {
throw TestUtil.rethrow(e);
}
@@ -634,19 +635,19 @@ class CsvTest {
connection.getMetaData().getColumns(null, null,
"DATE", "JOINEDAT");
res.next();
- assertEquals(res.getInt("DATA_TYPE"), java.sql.Types.DATE);
+ assertThat(java.sql.Types.DATE, is(res.getInt("DATA_TYPE")));
res =
connection.getMetaData().getColumns(null, null,
"DATE", "JOINTIME");
res.next();
- assertEquals(res.getInt("DATA_TYPE"), java.sql.Types.TIME);
+ assertThat(java.sql.Types.TIME, is(res.getInt("DATA_TYPE")));
res =
connection.getMetaData().getColumns(null, null,
"DATE", "JOINTIMES");
res.next();
- assertEquals(res.getInt("DATA_TYPE"), java.sql.Types.TIMESTAMP);
+ assertThat(java.sql.Types.TIMESTAMP, is(res.getInt("DATA_TYPE")));
Statement statement = connection.createStatement();
final String sql = "select \"JOINEDAT\", \"JOINTIME\", \"JOINTIMES\" "
@@ -655,21 +656,17 @@ class CsvTest {
resultSet.next();
// date
- assertEquals(java.sql.Date.class, resultSet.getDate(1).getClass());
- assertEquals(java.sql.Date.valueOf("1996-08-03"),
- resultSet.getDate(1));
+ assertThat(resultSet.getDate(1).getClass(), is(java.sql.Date.class));
+ assertThat(resultSet.getDate(1), is(java.sql.Date.valueOf("1996-08-03")));
// time
- assertEquals(java.sql.Time.class, resultSet.getTime(2).getClass());
- assertEquals(java.sql.Time.valueOf("00:01:02"),
- resultSet.getTime(2));
+ assertThat(resultSet.getTime(2).getClass(), is(java.sql.Time.class));
+ assertThat(resultSet.getTime(2), is(java.sql.Time.valueOf("00:01:02")));
// timestamp
- assertEquals(java.sql.Timestamp.class,
- resultSet.getTimestamp(3).getClass());
- assertEquals(java.sql.Timestamp.valueOf("1996-08-03 00:01:02"),
- resultSet.getTimestamp(3));
-
+ assertThat(resultSet.getTimestamp(3).getClass(), is(Timestamp.class));
+ assertThat(resultSet.getTimestamp(3),
+ is(Timestamp.valueOf("1996-08-03 00:01:02")));
}
}
diff --git a/file/src/test/java/org/apache/calcite/adapter/file/CsvEnumeratorTest.java b/file/src/test/java/org/apache/calcite/adapter/file/CsvEnumeratorTest.java
index 0a60329d04..43f4a6b24f 100644
--- a/file/src/test/java/org/apache/calcite/adapter/file/CsvEnumeratorTest.java
+++ b/file/src/test/java/org/apache/calcite/adapter/file/CsvEnumeratorTest.java
@@ -20,39 +20,41 @@ import org.junit.jupiter.api.Test;
import java.math.BigDecimal;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
/**
* Test for the {@link CsvEnumerator}.
*/
+@SuppressWarnings("SameParameterValue")
class CsvEnumeratorTest {
@Test void testParseDecimalScaleRounding() {
- assertEquals(new BigDecimal("123.45"),
- CsvEnumerator.parseDecimal(5, 2, "123.45"));
- assertEquals(new BigDecimal("123.46"),
- CsvEnumerator.parseDecimal(5, 2, "123.455"));
- assertEquals(new BigDecimal("-123.46"),
- CsvEnumerator.parseDecimal(5, 2, "-123.455"));
- assertEquals(new BigDecimal("123.45"),
- CsvEnumerator.parseDecimal(5, 2, "123.454"));
- assertEquals(new BigDecimal("-123.45"),
- CsvEnumerator.parseDecimal(5, 2, "-123.454"));
+ checkParse("123.45", 5, 2, "123.45");
+ checkParse("123.455", 5, 2, "123.46");
+ checkParse("-123.455", 5, 2, "-123.46");
+ checkParse("123.454", 5, 2, "123.45");
+ checkParse("-123.454", 5, 2, "-123.45");
+ }
+
+ private static void checkParse(String s, int precision, int scale,
+ String expected) {
+ assertThat(CsvEnumerator.parseDecimal(precision, scale, s),
+ is(new BigDecimal(expected)));
}
@Test void testParseDecimalPrecisionExceeded() {
+ checkThrows(4, 0, "1e+5");
+ checkThrows(4, 0, "-1e+5");
+ checkThrows(4, 0, "12345");
+ checkThrows(4, 0, "-12345");
+ checkThrows(4, 2, "123.45");
+ checkThrows(4, 2, "-123.45");
+ }
+
+ private static void checkThrows(int precision, int scale, String s) {
assertThrows(IllegalArgumentException.class,
- () -> CsvEnumerator.parseDecimal(4, 0, "1e+5"));
- assertThrows(IllegalArgumentException.class,
- () -> CsvEnumerator.parseDecimal(4, 0, "-1e+5"));
- assertThrows(IllegalArgumentException.class,
- () -> CsvEnumerator.parseDecimal(4, 0, "12345"));
- assertThrows(IllegalArgumentException.class,
- () -> CsvEnumerator.parseDecimal(4, 0, "-12345"));
- assertThrows(IllegalArgumentException.class,
- () -> CsvEnumerator.parseDecimal(4, 2, "123.45"));
- assertThrows(IllegalArgumentException.class,
- () -> CsvEnumerator.parseDecimal(4, 2, "-123.45"));
+ () -> CsvEnumerator.parseDecimal(precision, scale, s));
}
}
diff --git a/file/src/test/java/org/apache/calcite/adapter/file/FileAdapterTest.java b/file/src/test/java/org/apache/calcite/adapter/file/FileAdapterTest.java
index 9464807605..0d0fdc031c 100644
--- a/file/src/test/java/org/apache/calcite/adapter/file/FileAdapterTest.java
+++ b/file/src/test/java/org/apache/calcite/adapter/file/FileAdapterTest.java
@@ -51,7 +51,6 @@ import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.isA;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
/**
@@ -626,9 +625,9 @@ class FileAdapterTest {
.checking(resultSet -> {
try {
ResultSetMetaData metaData = resultSet.getMetaData();
- assertEquals("DECIMAL", metaData.getColumnTypeName(1));
- assertEquals(18, metaData.getPrecision(1));
- assertEquals(2, metaData.getScale(1));
+ assertThat(metaData.getColumnTypeName(1), is("DECIMAL"));
+ assertThat(metaData.getPrecision(1), is(18));
+ assertThat(metaData.getScale(1), is(2));
} catch (SQLException e) {
throw TestUtil.rethrow(e);
}
@@ -641,8 +640,8 @@ class FileAdapterTest {
.checking(resultSet -> {
try {
resultSet.next();
- assertEquals(0,
- resultSet.getBigDecimal(1).compareTo(new BigDecimal("200")));
+ final BigDecimal bd200 = new BigDecimal("200");
+ assertThat(resultSet.getBigDecimal(1).compareTo(bd200), is(0));
assertFalse(resultSet.next());
} catch (SQLException e) {
throw TestUtil.rethrow(e);
@@ -653,8 +652,8 @@ class FileAdapterTest {
.checking(resultSet -> {
try {
resultSet.next();
- assertEquals(0,
- resultSet.getBigDecimal(1).compareTo(new BigDecimal("0")));
+ final BigDecimal bd0 = BigDecimal.ZERO;
+ assertThat(resultSet.getBigDecimal(1).compareTo(bd0), is(0));
assertFalse(resultSet.next());
} catch (SQLException e) {
throw TestUtil.rethrow(e);
@@ -665,8 +664,8 @@ class FileAdapterTest {
.checking(resultSet -> {
try {
resultSet.next();
- assertEquals(0,
- resultSet.getBigDecimal(1).compareTo(new BigDecimal("1")));
+ final BigDecimal bd1 = new BigDecimal("1");
+ assertThat(resultSet.getBigDecimal(1).compareTo(bd1), is(0));
assertFalse(resultSet.next());
} catch (SQLException e) {
throw TestUtil.rethrow(e);
@@ -677,8 +676,8 @@ class FileAdapterTest {
.checking(resultSet -> {
try {
resultSet.next();
- assertEquals(0,
- resultSet.getBigDecimal(1).compareTo(new BigDecimal("1")));
+ final BigDecimal bd1 = new BigDecimal("1");
+ assertThat(resultSet.getBigDecimal(1).compareTo(bd1), is(0));
assertFalse(resultSet.next());
} catch (SQLException e) {
throw TestUtil.rethrow(e);
@@ -697,19 +696,19 @@ class FileAdapterTest {
connection.getMetaData().getColumns(null, null,
"DATE", "JOINEDAT");
res.next();
- assertEquals(res.getInt("DATA_TYPE"), Types.DATE);
+ assertThat(Types.DATE, is(res.getInt("DATA_TYPE")));
res =
connection.getMetaData().getColumns(null, null,
"DATE", "JOINTIME");
res.next();
- assertEquals(res.getInt("DATA_TYPE"), Types.TIME);
+ assertThat(Types.TIME, is(res.getInt("DATA_TYPE")));
res =
connection.getMetaData().getColumns(null, null,
"DATE", "JOINTIMES");
res.next();
- assertEquals(res.getInt("DATA_TYPE"), Types.TIMESTAMP);
+ assertThat(Types.TIMESTAMP, is(res.getInt("DATA_TYPE")));
Statement statement = connection.createStatement();
final String sql = "select \"JOINEDAT\", \"JOINTIME\", \"JOINTIMES\" "
@@ -718,17 +717,17 @@ class FileAdapterTest {
resultSet.next();
// date
- assertEquals(Date.class, resultSet.getDate(1).getClass());
- assertEquals(Date.valueOf("1996-08-03"), resultSet.getDate(1));
+ assertThat(resultSet.getDate(1).getClass(), is(Date.class));
+ assertThat(resultSet.getDate(1), is(Date.valueOf("1996-08-03")));
// time
- assertEquals(Time.class, resultSet.getTime(2).getClass());
- assertEquals(Time.valueOf("00:01:02"), resultSet.getTime(2));
+ assertThat(resultSet.getTime(2).getClass(), is(Time.class));
+ assertThat(resultSet.getTime(2), is(Time.valueOf("00:01:02")));
// timestamp
- assertEquals(Timestamp.class, resultSet.getTimestamp(3).getClass());
- assertEquals(Timestamp.valueOf("1996-08-03 00:01:02"),
- resultSet.getTimestamp(3));
+ assertThat(resultSet.getTimestamp(3).getClass(), is(Timestamp.class));
+ assertThat(resultSet.getTimestamp(3),
+ is(Timestamp.valueOf("1996-08-03 00:01:02")));
}
}
diff --git a/file/src/test/java/org/apache/calcite/adapter/file/FileAdapterTests.java b/file/src/test/java/org/apache/calcite/adapter/file/FileAdapterTests.java
index 70441989ae..7caea64e9d 100644
--- a/file/src/test/java/org/apache/calcite/adapter/file/FileAdapterTests.java
+++ b/file/src/test/java/org/apache/calcite/adapter/file/FileAdapterTests.java
@@ -39,7 +39,10 @@ import java.util.List;
import java.util.Properties;
import java.util.function.Consumer;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.apache.calcite.test.Matchers.isListOf;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
import static java.util.Objects.requireNonNull;
@@ -59,7 +62,7 @@ abstract class FileAdapterTests {
try {
final List<String> lines = new ArrayList<>();
collect(lines, resultSet);
- assertEquals(Arrays.asList(expected), lines);
+ assertThat(lines, isListOf(expected));
} catch (SQLException e) {
throw TestUtil.rethrow(e);
}
@@ -76,7 +79,7 @@ abstract class FileAdapterTests {
final List<String> lines = new ArrayList<>();
collect(lines, resultSet);
Collections.sort(lines);
- assertEquals(expectedLines, lines);
+ assertThat(lines, is(expectedLines));
} catch (SQLException e) {
throw TestUtil.rethrow(e);
}
diff --git a/file/src/test/java/org/apache/calcite/adapter/file/FileReaderTest.java b/file/src/test/java/org/apache/calcite/adapter/file/FileReaderTest.java
index da1e4bc0f6..f939522fb1 100644
--- a/file/src/test/java/org/apache/calcite/adapter/file/FileReaderTest.java
+++ b/file/src/test/java/org/apache/calcite/adapter/file/FileReaderTest.java
@@ -39,9 +39,8 @@ import static org.apache.calcite.util.TestUtil.getJavaMajorVersion;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
import static org.junit.jupiter.api.Assumptions.assumeTrue;
@@ -147,7 +146,7 @@ class FileReaderTest {
final Source source = resource("tableOK.html");
FileReader t = new FileReader(source);
Elements headings = t.getHeadings();
- assertTrue(headings.get(1).text().equals("H1"));
+ assertThat(headings.get(1).text(), is("H1"));
}
/** Test {@link FileReader} with static file - data. */
@@ -156,9 +155,9 @@ class FileReaderTest {
FileReader t = new FileReader(source);
Iterator<Elements> i = t.iterator();
Elements row = i.next();
- assertTrue(row.get(2).text().equals("R0C2"));
+ assertThat(row.get(2).text(), is("R0C2"));
row = i.next();
- assertTrue(row.get(0).text().equals("R1C0"));
+ assertThat(row.get(0).text(), is("R1C0"));
}
/** Tests {@link FileReader} with bad static file - headings. */
@@ -166,7 +165,7 @@ class FileReaderTest {
final Source source = resource("tableNoTheadTbody.html");
FileReader t = new FileReader(source);
Elements headings = t.getHeadings();
- assertTrue(headings.get(1).text().equals("H1"));
+ assertThat(headings.get(1).text(), is("H1"));
}
/** Tests {@link FileReader} with bad static file - data. */
@@ -175,9 +174,9 @@ class FileReaderTest {
FileReader t = new FileReader(source);
Iterator<Elements> i = t.iterator();
Elements row = i.next();
- assertTrue(row.get(2).text().equals("R0C2"));
+ assertThat(row.get(2).text(), is("R0C2"));
row = i.next();
- assertTrue(row.get(0).text().equals("R1C0"));
+ assertThat(row.get(0).text(), is("R1C0"));
}
/** Tests {@link FileReader} with no headings static file - data. */
@@ -186,7 +185,7 @@ class FileReaderTest {
FileReader t = new FileReader(source);
Iterator<Elements> i = t.iterator();
Elements row = i.next();
- assertTrue(row.get(2).text().equals("R0C2"));
+ assertThat(row.get(2).text(), is("R0C2"));
}
/** Tests {@link FileReader} iterator with a static file. */
@@ -197,8 +196,8 @@ class FileReaderTest {
for (Elements aT : t) {
row = aT;
}
- assertFalse(row == null);
- assertTrue(row.get(1).text().equals("R2C1"));
+ assertNotNull(row);
+ assertThat(row.get(1).text(), is("R2C1"));
}
/** Tests reading a CSV file via the file adapter. Based on the test case for
diff --git a/geode/src/test/java/org/apache/calcite/adapter/geode/rel/GeodeAssertions.java b/geode/src/test/java/org/apache/calcite/adapter/geode/rel/GeodeAssertions.java
index 426981292a..7f58a00633 100644
--- a/geode/src/test/java/org/apache/calcite/adapter/geode/rel/GeodeAssertions.java
+++ b/geode/src/test/java/org/apache/calcite/adapter/geode/rel/GeodeAssertions.java
@@ -19,7 +19,8 @@ package org.apache.calcite.adapter.geode.rel;
import java.util.List;
import java.util.function.Consumer;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
/**
* Various validations for geode tests.
@@ -35,7 +36,7 @@ class GeodeAssertions {
? null
: ((String) actual.get(0));
- assertEquals(query, actualString);
+ assertThat(actualString, is(query));
};
}
diff --git a/linq4j/src/test/java/org/apache/calcite/linq4j/function/FunctionTest.java b/linq4j/src/test/java/org/apache/calcite/linq4j/function/FunctionTest.java
index 1e0fd66425..8fba589350 100644
--- a/linq4j/src/test/java/org/apache/calcite/linq4j/function/FunctionTest.java
+++ b/linq4j/src/test/java/org/apache/calcite/linq4j/function/FunctionTest.java
@@ -23,7 +23,8 @@ import java.util.Collections;
import java.util.List;
import java.util.function.IntFunction;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.hasToString;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -37,14 +38,14 @@ class FunctionTest {
@Test void testFilter() {
final List<String> abc = Arrays.asList("A", "B", "C", "D");
// a miss, then a hit
- assertEquals("[A, C, D]",
- Functions.filter(abc, v1 -> !v1.equals("B")).toString());
+ assertThat(Functions.filter(abc, v1 -> !v1.equals("B")),
+ hasToString("[A, C, D]"));
// a hit, then all misses
- assertEquals("[A]",
- Functions.filter(abc, v1 -> v1.equals("A")).toString());
+ assertThat(Functions.filter(abc, v1 -> v1.equals("A")),
+ hasToString("[A]"));
// two hits, then a miss
- assertEquals("[A, B, D]",
- Functions.filter(abc, v1 -> !v1.equals("C")).toString());
+ assertThat(Functions.filter(abc, v1 -> !v1.equals("C")),
+ hasToString("[A, B, D]"));
assertSame(Collections.emptyList(),
Functions.filter(abc, Functions.falsePredicate1()));
assertSame(abc,
@@ -87,12 +88,9 @@ class FunctionTest {
return a0 == 0 ? "0" : "x" + apply(a0 - 1);
}
};
- assertEquals(
- "[]", Functions.generate(0, xx).toString());
- assertEquals(
- "[0]", Functions.generate(1, xx).toString());
- assertEquals(
- "[0, x0, xx0]", Functions.generate(3, xx).toString());
+ assertThat(Functions.generate(0, xx), hasToString("[]"));
+ assertThat(Functions.generate(1, xx), hasToString("[0]"));
+ assertThat(Functions.generate(3, xx), hasToString("[0, x0, xx0]"));
try {
final List<String> generate = Functions.generate(-2, xx);
fail("expected error, got " + generate);
diff --git a/linq4j/src/test/java/org/apache/calcite/linq4j/test/BlockBuilderTest.java b/linq4j/src/test/java/org/apache/calcite/linq4j/test/BlockBuilderTest.java
index 07023ae48d..181a067f75 100644
--- a/linq4j/src/test/java/org/apache/calcite/linq4j/test/BlockBuilderTest.java
+++ b/linq4j/src/test/java/org/apache/calcite/linq4j/test/BlockBuilderTest.java
@@ -36,7 +36,9 @@ import static org.apache.calcite.linq4j.test.BlockBuilderBase.FOUR;
import static org.apache.calcite.linq4j.test.BlockBuilderBase.ONE;
import static org.apache.calcite.linq4j.test.BlockBuilderBase.TWO;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.hasToString;
/**
* Tests BlockBuilder.
@@ -55,14 +57,13 @@ class BlockBuilderTest {
Expression y = nested.append("y", Expressions.add(ONE, TWO));
nested.add(Expressions.return_(null, Expressions.add(y, y)));
b.add(nested.toBlock());
- assertEquals(
- "{\n"
+ assertThat(b.toBlock(),
+ hasToString("{\n"
+ " final int x = 1 + 2;\n"
+ " {\n"
+ " return x + x;\n"
+ " }\n"
... 4673 lines suppressed ...
(calcite) 02/02: [CALCITE-6560] Allow types with negative scale
Posted by jh...@apache.org.
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
commit a4a27e3a48db7451cb9d95eda3883c111b638f26
Author: Xiong Duan <no...@gmail.com>
AuthorDate: Sun Sep 22 06:45:20 2024 +0800
[CALCITE-6560] Allow types with negative scale
In RelDataTypeSystem, add methods getMinScale(SqlTypeName)
and getDefaultScale(SqlTypeName), deprecating the SqlTypeName
methods getMinScale(), getDefaultScale(), getMinPrecision().
Change parser to allow negative scale;
Move class CustomRelDataTypeSystem to testkit, and rename it
to CustomTypeSystems.
Close apache/calcite#3945
---
core/src/main/codegen/templates/Parser.jj | 6 +-
.../org/apache/calcite/jdbc/CalciteMetaImpl.java | 2 +-
.../calcite/rel/type/DelegatingTypeSystem.java | 12 +
.../apache/calcite/rel/type/RelDataTypeSystem.java | 49 ++-
.../calcite/rel/type/RelDataTypeSystemImpl.java | 101 ++++++
.../java/org/apache/calcite/rex/RexBuilder.java | 5 +-
.../apache/calcite/runtime/CalciteResource.java | 6 +
.../apache/calcite/sql/SqlBasicTypeNameSpec.java | 15 +-
.../apache/calcite/sql/SqlIntervalQualifier.java | 2 +-
.../calcite/sql/type/SqlTypeFactoryImpl.java | 17 +-
.../org/apache/calcite/sql/type/SqlTypeName.java | 19 +-
.../org/apache/calcite/sql/type/SqlTypeUtil.java | 8 +-
.../calcite/sql/validate/SqlValidatorImpl.java | 4 +-
.../calcite/runtime/CalciteResource.properties | 4 +
.../org/apache/calcite/rex/RexBuilderTest.java | 61 ++++
.../calcite/sql/type/RelDataTypeSystemTest.java | 26 ++
.../org/apache/calcite/test/CoreQuidemTest.java | 26 +-
.../calcite/test/CustomRelDataTypeSystem.java | 40 ---
.../org/apache/calcite/test/SqlValidatorTest.java | 6 +-
core/src/test/resources/sql/cast.iq | 381 +++++++++++++++++++++
.../org/apache/calcite/linq4j/tree/Primitive.java | 5 +
.../apache/calcite/sql/parser/SqlParserTest.java | 24 ++
.../org/apache/calcite/test/CustomTypeSystems.java | 96 ++++++
.../org/apache/calcite/test/SqlOperatorTest.java | 41 +++
24 files changed, 882 insertions(+), 74 deletions(-)
diff --git a/core/src/main/codegen/templates/Parser.jj b/core/src/main/codegen/templates/Parser.jj
index 8e854ce3fa..b26efd896e 100644
--- a/core/src/main/codegen/templates/Parser.jj
+++ b/core/src/main/codegen/templates/Parser.jj
@@ -5930,8 +5930,8 @@ SqlTypeNameSpec SqlTypeName2(Span s) :
SqlTypeNameSpec SqlTypeName3(Span s) :
{
final SqlTypeName sqlTypeName;
- int precision = -1;
- int scale = -1;
+ int precision = RelDataType.PRECISION_NOT_SPECIFIED;
+ int scale = RelDataType.SCALE_NOT_SPECIFIED;
}
{
(
@@ -5944,7 +5944,7 @@ SqlTypeNameSpec SqlTypeName3(Span s) :
precision = UnsignedIntLiteral()
[
<COMMA>
- scale = UnsignedIntLiteral()
+ scale = IntLiteral()
]
<RPAREN>
]
diff --git a/core/src/main/java/org/apache/calcite/jdbc/CalciteMetaImpl.java b/core/src/main/java/org/apache/calcite/jdbc/CalciteMetaImpl.java
index 4677801d4e..0217c05ad3 100644
--- a/core/src/main/java/org/apache/calcite/jdbc/CalciteMetaImpl.java
+++ b/core/src/main/java/org/apache/calcite/jdbc/CalciteMetaImpl.java
@@ -517,7 +517,7 @@ public class CalciteMetaImpl extends MetaImpl {
false,
false,
typeSystem.isAutoincrement(sqlTypeName),
- (short) sqlTypeName.getMinScale(),
+ (short) typeSystem.getMinScale(sqlTypeName),
(short) typeSystem.getMaxScale(sqlTypeName),
typeSystem.getNumTypeRadix(sqlTypeName)));
}
diff --git a/core/src/main/java/org/apache/calcite/rel/type/DelegatingTypeSystem.java b/core/src/main/java/org/apache/calcite/rel/type/DelegatingTypeSystem.java
index edc8d16d50..f6a77bafd8 100644
--- a/core/src/main/java/org/apache/calcite/rel/type/DelegatingTypeSystem.java
+++ b/core/src/main/java/org/apache/calcite/rel/type/DelegatingTypeSystem.java
@@ -36,14 +36,26 @@ public class DelegatingTypeSystem implements RelDataTypeSystem {
return typeSystem.getMaxScale(typeName);
}
+ @Override public int getMinScale(SqlTypeName typeName) {
+ return typeSystem.getMinScale(typeName);
+ }
+
@Override public int getDefaultPrecision(SqlTypeName typeName) {
return typeSystem.getDefaultPrecision(typeName);
}
+ @Override public int getDefaultScale(SqlTypeName typeName) {
+ return typeSystem.getDefaultScale(typeName);
+ }
+
@Override public int getMaxPrecision(SqlTypeName typeName) {
return typeSystem.getMaxPrecision(typeName);
}
+ @Override public int getMinPrecision(SqlTypeName typeName) {
+ return typeSystem.getMinPrecision(typeName);
+ }
+
@Override public int getMaxNumericScale() {
return typeSystem.getMaxNumericScale();
}
diff --git a/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeSystem.java b/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeSystem.java
index ebe900650e..fd9464b3eb 100644
--- a/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeSystem.java
+++ b/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeSystem.java
@@ -37,29 +37,64 @@ public interface RelDataTypeSystem {
/** Default type system. */
RelDataTypeSystem DEFAULT = new RelDataTypeSystemImpl() { };
- /** Returns the maximum scale of a given type. */
+ /**
+ * Returns the maximum scale allowed for this type, or
+ * {@link RelDataType#SCALE_NOT_SPECIFIED}
+ * if scale is not applicable for this type.
+ *
+ * @return Maximum allowed scale
+ */
int getMaxScale(SqlTypeName typeName);
/**
- * Returns default precision for this type if supported, otherwise -1 if
- * precision is either unsupported or must be specified explicitly.
+ * Returns the minimum scale allowed for this type, or
+ * {@link RelDataType#SCALE_NOT_SPECIFIED}
+ * if scale are not applicable for this type.
+ *
+ * @return Minimum allowed scale
+ */
+ int getMinScale(SqlTypeName typeName);
+
+ /**
+ * Returns default precision for this type if supported, otherwise
+ * {@link RelDataType#PRECISION_NOT_SPECIFIED}
+ * if precision is either unsupported or must be specified explicitly.
*
* @return Default precision
*/
int getDefaultPrecision(SqlTypeName typeName);
/**
- * Returns the maximum precision (or length) allowed for this type, or -1 if
- * precision/length are not applicable for this type.
+ * Returns default scale for this type if supported, otherwise
+ * {@link RelDataType#SCALE_NOT_SPECIFIED}
+ * if scale is either unsupported or must be specified explicitly.
+ *
+ * @return Default scale
+ */
+ int getDefaultScale(SqlTypeName typeName);
+
+ /**
+ * Returns the maximum precision (or length) allowed for this type, or
+ * {@link RelDataType#PRECISION_NOT_SPECIFIED}
+ * if precision/length are not applicable for this type.
*
* @return Maximum allowed precision
*/
int getMaxPrecision(SqlTypeName typeName);
- /** Returns the maximum scale of a NUMERIC or DECIMAL type. */
+ /**
+ * Returns the minimum precision (or length) allowed for this type, or
+ * {@link RelDataType#PRECISION_NOT_SPECIFIED}
+ * if precision/length are not applicable for this type.
+ *
+ * @return Minimum allowed precision
+ */
+ int getMinPrecision(SqlTypeName typeName);
+
+ /** Returns the maximum scale of a NUMERIC or DECIMAL type. And the default value is 19. */
int getMaxNumericScale();
- /** Returns the maximum precision of a NUMERIC or DECIMAL type. */
+ /** Returns the maximum precision of a NUMERIC or DECIMAL type. And the default value is 19. */
int getMaxNumericPrecision();
/** Returns the rounding behavior for numerical operations capable of discarding precision. */
diff --git a/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeSystemImpl.java b/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeSystemImpl.java
index b7fe0d8680..ef5c5c91ce 100644
--- a/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeSystemImpl.java
+++ b/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeSystemImpl.java
@@ -24,6 +24,10 @@ import org.checkerframework.checker.nullness.qual.Nullable;
import java.math.RoundingMode;
+import static org.apache.calcite.sql.type.SqlTypeName.DEFAULT_INTERVAL_FRACTIONAL_SECOND_PRECISION;
+import static org.apache.calcite.sql.type.SqlTypeName.MIN_INTERVAL_FRACTIONAL_SECOND_PRECISION;
+import static org.apache.calcite.sql.type.SqlTypeName.MIN_INTERVAL_START_PRECISION;
+
/** Default implementation of
* {@link org.apache.calcite.rel.type.RelDataTypeSystem},
* providing parameters from the SQL standard.
@@ -35,6 +39,8 @@ import java.math.RoundingMode;
* <caption>Parameter values</caption>
* <tr><th>Parameter</th> <th>Value</th></tr>
* <tr><td>MAX_NUMERIC_SCALE</td> <td>19</td></tr>
+ * <tr><td>MIN_NUMERIC_SCALE</td> <td>0</td></tr>
+ * <tr><td>MAX_NUMERIC_PRECISION</td> <td>19</td></tr>
* </table>
*/
public abstract class RelDataTypeSystemImpl implements RelDataTypeSystem {
@@ -61,6 +67,36 @@ public abstract class RelDataTypeSystemImpl implements RelDataTypeSystem {
}
}
+ /**
+ * Returns the minimum scale (or fractional second precision in the case of
+ * intervals) allowed for this type, or {@link RelDataType#SCALE_NOT_SPECIFIED}
+ * if precision/length are not applicable for this type.
+ *
+ * @return Minimum allowed scale
+ */
+ @Override public int getMinScale(SqlTypeName typeName) {
+ switch (typeName) {
+ case DECIMAL:
+ return 0;
+ case INTERVAL_YEAR:
+ case INTERVAL_YEAR_MONTH:
+ case INTERVAL_MONTH:
+ case INTERVAL_DAY:
+ case INTERVAL_DAY_HOUR:
+ case INTERVAL_DAY_MINUTE:
+ case INTERVAL_DAY_SECOND:
+ case INTERVAL_HOUR:
+ case INTERVAL_HOUR_MINUTE:
+ case INTERVAL_HOUR_SECOND:
+ case INTERVAL_MINUTE:
+ case INTERVAL_MINUTE_SECOND:
+ case INTERVAL_SECOND:
+ return MIN_INTERVAL_FRACTIONAL_SECOND_PRECISION;
+ default:
+ return RelDataType.SCALE_NOT_SPECIFIED;
+ }
+ }
+
@Override public int getDefaultPrecision(SqlTypeName typeName) {
// Following BasicSqlType precision as the default
switch (typeName) {
@@ -118,6 +154,31 @@ public abstract class RelDataTypeSystemImpl implements RelDataTypeSystem {
}
}
+ /** Returns the default scale for this type if supported, otherwise {@link RelDataType#SCALE_NOT_SPECIFIED}
+ * if scale is either unsupported or must be specified explicitly. */
+ @Override public int getDefaultScale(SqlTypeName typeName) {
+ switch (typeName) {
+ case DECIMAL:
+ return 0;
+ case INTERVAL_YEAR:
+ case INTERVAL_YEAR_MONTH:
+ case INTERVAL_MONTH:
+ case INTERVAL_DAY:
+ case INTERVAL_DAY_HOUR:
+ case INTERVAL_DAY_MINUTE:
+ case INTERVAL_DAY_SECOND:
+ case INTERVAL_HOUR:
+ case INTERVAL_HOUR_MINUTE:
+ case INTERVAL_HOUR_SECOND:
+ case INTERVAL_MINUTE:
+ case INTERVAL_MINUTE_SECOND:
+ case INTERVAL_SECOND:
+ return DEFAULT_INTERVAL_FRACTIONAL_SECOND_PRECISION;
+ default:
+ return RelDataType.SCALE_NOT_SPECIFIED;
+ }
+ }
+
@Override public int getMaxPrecision(SqlTypeName typeName) {
switch (typeName) {
case DECIMAL:
@@ -154,6 +215,46 @@ public abstract class RelDataTypeSystemImpl implements RelDataTypeSystem {
}
}
+ /**
+ * Returns the minimum precision (or length) allowed for this type,
+ * or {@link RelDataType#PRECISION_NOT_SPECIFIED}
+ * if precision/length are not applicable for this type.
+ *
+ * @return Minimum allowed precision
+ */
+ @Override public int getMinPrecision(SqlTypeName typeName) {
+ switch (typeName) {
+ case DECIMAL:
+ case VARCHAR:
+ case CHAR:
+ case VARBINARY:
+ case BINARY:
+ case TIME:
+ case TIME_WITH_LOCAL_TIME_ZONE:
+ case TIME_TZ:
+ case TIMESTAMP:
+ case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
+ case TIMESTAMP_TZ:
+ return 1;
+ case INTERVAL_YEAR:
+ case INTERVAL_YEAR_MONTH:
+ case INTERVAL_MONTH:
+ case INTERVAL_DAY:
+ case INTERVAL_DAY_HOUR:
+ case INTERVAL_DAY_MINUTE:
+ case INTERVAL_DAY_SECOND:
+ case INTERVAL_HOUR:
+ case INTERVAL_HOUR_MINUTE:
+ case INTERVAL_HOUR_SECOND:
+ case INTERVAL_MINUTE:
+ case INTERVAL_MINUTE_SECOND:
+ case INTERVAL_SECOND:
+ return MIN_INTERVAL_START_PRECISION;
+ default:
+ return RelDataType.PRECISION_NOT_SPECIFIED;
+ }
+ }
+
@Override public int getMaxNumericScale() {
return 19;
}
diff --git a/core/src/main/java/org/apache/calcite/rex/RexBuilder.java b/core/src/main/java/org/apache/calcite/rex/RexBuilder.java
index 3ebabd164c..30d3383ab4 100644
--- a/core/src/main/java/org/apache/calcite/rex/RexBuilder.java
+++ b/core/src/main/java/org/apache/calcite/rex/RexBuilder.java
@@ -1338,7 +1338,10 @@ public class RexBuilder {
case DECIMAL:
if (o != null && type.getScale() != RelDataType.SCALE_NOT_SPECIFIED) {
assert o instanceof BigDecimal;
- o = ((BigDecimal) o).setScale(type.getScale(), RoundingMode.DOWN);
+ o = ((BigDecimal) o).setScale(type.getScale(), typeFactory.getTypeSystem().roundingMode());
+ if (type.getScale() < 0) {
+ o = new BigDecimal(((BigDecimal) o).toPlainString());
+ }
}
break;
default:
diff --git a/core/src/main/java/org/apache/calcite/runtime/CalciteResource.java b/core/src/main/java/org/apache/calcite/runtime/CalciteResource.java
index 85a995a945..adccdf563e 100644
--- a/core/src/main/java/org/apache/calcite/runtime/CalciteResource.java
+++ b/core/src/main/java/org/apache/calcite/runtime/CalciteResource.java
@@ -942,6 +942,12 @@ public interface CalciteResource {
@BaseMessage("Illegal arguments for 'MAP_VALUES' function: using a map with a null key is not allowed")
ExInst<CalciteException> illegalMapValuesWithNullKey();
+ @BaseMessage("DECIMAL precision {0,number,#} must be between 1 and {1,number,#}")
+ ExInst<CalciteException> invalidPrecisionForDecimalType(int precision, int maxPrecision);
+
+ @BaseMessage("DECIMAL scale {0,number,#} must be between {1,number,#} and {2,number,#}")
+ ExInst<CalciteException> invalidScaleForDecimalType(int scale, int minScale, int maxScale);
+
@BaseMessage("Illegal arguments: The length of the keys array {0,number,#} is not equal to the length of the values array {1,number,#} in MAP_FROM_ARRAYS function")
ExInst<CalciteException> illegalArgumentsInMapFromArraysFunc(int arg0, int arg1);
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlBasicTypeNameSpec.java b/core/src/main/java/org/apache/calcite/sql/SqlBasicTypeNameSpec.java
index 08f4de6ffd..fb1513bcf4 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlBasicTypeNameSpec.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlBasicTypeNameSpec.java
@@ -105,16 +105,16 @@ public class SqlBasicTypeNameSpec extends SqlTypeNameSpec {
}
public SqlBasicTypeNameSpec(SqlTypeName typeName, SqlParserPos pos) {
- this(typeName, -1, -1, null, pos);
+ this(typeName, RelDataType.PRECISION_NOT_SPECIFIED, RelDataType.SCALE_NOT_SPECIFIED, null, pos);
}
public SqlBasicTypeNameSpec(SqlTypeName typeName, int precision, SqlParserPos pos) {
- this(typeName, precision, -1, null, pos);
+ this(typeName, precision, RelDataType.SCALE_NOT_SPECIFIED, null, pos);
}
public SqlBasicTypeNameSpec(SqlTypeName typeName, int precision,
String charSetName, SqlParserPos pos) {
- this(typeName, precision, -1, charSetName, pos);
+ this(typeName, precision, RelDataType.SCALE_NOT_SPECIFIED, charSetName, pos);
}
public SqlBasicTypeNameSpec(SqlTypeName typeName, int precision,
@@ -167,11 +167,11 @@ public class SqlBasicTypeNameSpec extends SqlTypeNameSpec {
writer.keyword(getTypeName().getSimple());
}
- if (sqlTypeName.allowsPrec() && (precision >= 0)) {
+ if (sqlTypeName.allowsPrec() && (precision != RelDataType.PRECISION_NOT_SPECIFIED)) {
final SqlWriter.Frame frame =
writer.startList(SqlWriter.FrameTypeEnum.FUN_CALL, "(", ")");
writer.print(precision);
- if (sqlTypeName.allowsScale() && (scale >= 0)) {
+ if (sqlTypeName.allowsScale() && (scale != RelDataType.SCALE_NOT_SPECIFIED)) {
writer.sep(",", true);
writer.print(scale);
}
@@ -198,10 +198,11 @@ public class SqlBasicTypeNameSpec extends SqlTypeNameSpec {
// NOTE jvs 15-Jan-2009: earlier validation is supposed to
// have caught these, which is why it's OK for them
// to be assertions rather than user-level exceptions.
- if ((precision >= 0) && (scale >= 0)) {
+ if ((precision != RelDataType.PRECISION_NOT_SPECIFIED)
+ && (scale != RelDataType.SCALE_NOT_SPECIFIED)) {
assert sqlTypeName.allowsPrecScale(true, true);
type = typeFactory.createSqlType(sqlTypeName, precision, scale);
- } else if (precision >= 0) {
+ } else if (precision != RelDataType.PRECISION_NOT_SPECIFIED) {
assert sqlTypeName.allowsPrecNoScale();
type = typeFactory.createSqlType(sqlTypeName, precision);
} else {
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlIntervalQualifier.java b/core/src/main/java/org/apache/calcite/sql/SqlIntervalQualifier.java
index 54cc16b462..5f81211b99 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlIntervalQualifier.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlIntervalQualifier.java
@@ -343,7 +343,7 @@ public class SqlIntervalQualifier extends SqlNode {
public int getFractionalSecondPrecision(RelDataTypeSystem typeSystem) {
if (fractionalSecondPrecision == RelDataType.PRECISION_NOT_SPECIFIED) {
- return typeName().getDefaultScale();
+ return typeSystem.getDefaultScale(typeName());
} else {
return fractionalSecondPrecision;
}
diff --git a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeFactoryImpl.java b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeFactoryImpl.java
index fcb1d65f6d..e49f4926b1 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeFactoryImpl.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeFactoryImpl.java
@@ -32,6 +32,8 @@ import java.util.List;
import static com.google.common.base.Preconditions.checkArgument;
+import static org.apache.calcite.util.Static.RESOURCE;
+
import static java.util.Objects.requireNonNull;
/**
@@ -59,13 +61,13 @@ public class SqlTypeFactoryImpl extends RelDataTypeFactoryImpl {
@Override public RelDataType createSqlType(
SqlTypeName typeName,
int precision) {
+ if (typeName.allowsScale()) {
+ return createSqlType(typeName, precision, typeSystem.getDefaultScale(typeName));
+ }
final int maxPrecision = typeSystem.getMaxPrecision(typeName);
if (maxPrecision >= 0 && precision > maxPrecision) {
precision = maxPrecision;
}
- if (typeName.allowsScale()) {
- return createSqlType(typeName, precision, typeName.getDefaultScale());
- }
assertBasic(typeName);
assert (precision >= 0)
|| (precision == RelDataType.PRECISION_NOT_SPECIFIED);
@@ -88,6 +90,15 @@ public class SqlTypeFactoryImpl extends RelDataTypeFactoryImpl {
if (maxPrecision >= 0 && precision > maxPrecision) {
precision = maxPrecision;
}
+ if (precision != RelDataType.PRECISION_NOT_SPECIFIED
+ && precision < typeSystem.getMinPrecision(typeName)) {
+ throw RESOURCE.invalidPrecisionForDecimalType(precision, maxPrecision).ex();
+ }
+ if (scale != RelDataType.SCALE_NOT_SPECIFIED
+ && scale < typeSystem.getMinScale(typeName)) {
+ throw RESOURCE.invalidScaleForDecimalType(scale,
+ typeSystem.getMinScale(typeName), typeSystem.getMaxNumericScale()).ex();
+ }
RelDataType newType =
new BasicSqlType(typeSystem, typeName, precision, scale);
newType = SqlTypeUtil.addCharsetAndCollation(newType, this);
diff --git a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeName.java b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeName.java
index 0c856e3ffa..e5a30dd581 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeName.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeName.java
@@ -394,7 +394,13 @@ public enum SqlTypeName {
}
/** Returns the default scale for this type if supported, otherwise -1 if
- * scale is either unsupported or must be specified explicitly. */
+ * scale is either unsupported or must be specified explicitly.
+ *
+ * @deprecated
+ * Use {@link org.apache.calcite.rel.type.RelDataTypeSystem#getDefaultScale(SqlTypeName)}
+ * but return Integer.MIN_VALUE if scale is unsupported.
+ */
+ @Deprecated
public int getDefaultScale() {
switch (this) {
case DECIMAL:
@@ -781,7 +787,11 @@ public enum SqlTypeName {
* precision/length are not applicable for this type.
*
* @return Minimum allowed precision
+ *
+ * @deprecated
+ * Use {@link org.apache.calcite.rel.type.RelDataTypeSystem#getMinPrecision(SqlTypeName)}.
*/
+ @Deprecated
public int getMinPrecision() {
switch (this) {
case DECIMAL:
@@ -817,11 +827,16 @@ public enum SqlTypeName {
/**
* Returns the minimum scale (or fractional second precision in the case of
- * intervals) allowed for this type, or -1 if precision/length are not
+ * intervals) allowed for this type, or -1 if scale are not
* applicable for this type.
*
* @return Minimum allowed scale
+ *
+ * @deprecated
+ * Use {@link org.apache.calcite.rel.type.RelDataTypeSystem#getMinScale(SqlTypeName)}
+ * but return Integer.MIN_VALUE if scale is unsupported.
*/
+ @Deprecated
public int getMinScale() {
switch (this) {
// TODO: Minimum numeric scale for decimal
diff --git a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeUtil.java b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeUtil.java
index 500a846eae..3ccd802727 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeUtil.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeUtil.java
@@ -1107,12 +1107,13 @@ public abstract class SqlTypeUtil {
if (isAtomic(type) || isNull(type)
|| type.getSqlTypeName() == SqlTypeName.UNKNOWN
|| type.getSqlTypeName() == SqlTypeName.GEOMETRY) {
- int precision = typeName.allowsPrec() ? type.getPrecision() : -1;
+ int precision =
+ typeName.allowsPrec() ? type.getPrecision() : RelDataType.PRECISION_NOT_SPECIFIED;
// fix up the precision.
if (maxPrecision > 0 && precision > maxPrecision) {
precision = maxPrecision;
}
- int scale = typeName.allowsScale() ? type.getScale() : -1;
+ int scale = typeName.allowsScale() ? type.getScale() : RelDataType.SCALE_NOT_SPECIFIED;
if (maxScale > 0 && scale > maxScale) {
scale = maxScale;
}
@@ -1166,7 +1167,8 @@ public abstract class SqlTypeUtil {
public static SqlDataTypeSpec convertTypeToSpec(RelDataType type) {
// TODO jvs 28-Dec-2004: collation
String charSetName = inCharFamily(type) ? type.getCharset().name() : null;
- return convertTypeToSpec(type, charSetName, -1, -1);
+ return convertTypeToSpec(type, charSetName,
+ RelDataType.PRECISION_NOT_SPECIFIED, RelDataType.SCALE_NOT_SPECIFIED);
}
public static RelDataType createMultisetType(
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
index c7a93359c7..020bfaedd8 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
@@ -3523,8 +3523,8 @@ public class SqlValidatorImpl implements SqlValidatorWithHints {
final int fracPrecision =
qualifier.getFractionalSecondPrecision(typeSystem);
final int maxPrecision = typeSystem.getMaxPrecision(qualifier.typeName());
- final int minPrecision = qualifier.typeName().getMinPrecision();
- final int minScale = qualifier.typeName().getMinScale();
+ final int minPrecision = typeSystem.getMinPrecision(qualifier.typeName());
+ final int minScale = typeSystem.getMinScale(qualifier.typeName());
final int maxScale = typeSystem.getMaxScale(qualifier.typeName());
if (startPrecision < minPrecision || startPrecision > maxPrecision) {
startPrecisionOutOfRange = true;
diff --git a/core/src/main/resources/org/apache/calcite/runtime/CalciteResource.properties b/core/src/main/resources/org/apache/calcite/runtime/CalciteResource.properties
index a16d5469c1..264cf56a89 100644
--- a/core/src/main/resources/org/apache/calcite/runtime/CalciteResource.properties
+++ b/core/src/main/resources/org/apache/calcite/runtime/CalciteResource.properties
@@ -307,6 +307,10 @@ IllegalNegativeSubstringLength=Substring error: negative substring length not al
IllegalMapEntriesWithNullKey=Illegal arguments for 'MAP_ENTRIES' function: using a map with a null key is not allowed
IllegalMapKeysWithNullKey=Illegal arguments for 'MAP_KEYS' function: using a map with a null key is not allowed
IllegalMapValuesWithNullKey=Illegal arguments for 'MAP_VALUES' function: using a map with a null key is not allowed
+InvalidPrecisionForDecimalType=DECIMAL precision {0,number,#} must be between 1 and max precision {1,number,#}
+InvalidNegativeScaleForDecimalType=DECIMAL scale {0,number,#} must be between greater than or equal to 0
+InvalidPrecisionForDecimalType=DECIMAL precision {0,number,#} must be between 1 and {1,number,#}
+InvalidScaleForDecimalType=DECIMAL scale {0,number,#} must be between {1,number,#} and {2,number,#}
IllegalArgumentsInMapFromArraysFunc=Illegal arguments: The length of the keys array {0,number,#} is not equal to the length of the values array {1,number,#} in MAP_FROM_ARRAYS function
TrimError=Trim error: trim character must be exactly 1 character
InvalidTypesForArithmetic=Invalid types for arithmetic: {0} {1} {2}
diff --git a/core/src/test/java/org/apache/calcite/rex/RexBuilderTest.java b/core/src/test/java/org/apache/calcite/rex/RexBuilderTest.java
index da062f1634..8329de9044 100644
--- a/core/src/test/java/org/apache/calcite/rex/RexBuilderTest.java
+++ b/core/src/test/java/org/apache/calcite/rex/RexBuilderTest.java
@@ -34,6 +34,7 @@ import org.apache.calcite.sql.fun.SqlStdOperatorTable;
import org.apache.calcite.sql.type.BasicSqlType;
import org.apache.calcite.sql.type.SqlTypeFactoryImpl;
import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.calcite.test.CustomTypeSystems;
import org.apache.calcite.test.RexImplicationCheckerFixtures;
import org.apache.calcite.util.DateString;
import org.apache.calcite.util.Litmus;
@@ -53,6 +54,7 @@ import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import java.math.BigDecimal;
+import java.math.RoundingMode;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Calendar;
@@ -704,6 +706,65 @@ class RexBuilderTest {
}
}
+ /** Tests {@link RexBuilder#makeExactLiteral(BigDecimal, RelDataType)}. */
+ @Test void testDecimalWithRoundingMode() {
+ final RelDataTypeFactory typeFactory =
+ new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
+ final RelDataType type = typeFactory.createSqlType(SqlTypeName.DECIMAL, 4, 2);
+ final RexBuilder builder = new RexBuilder(typeFactory);
+ RexLiteral rexLiteral = builder.makeExactLiteral(new BigDecimal("13.556"), type);
+ assertThat(rexLiteral.getValue() instanceof BigDecimal, is(true));
+ assertThat(rexLiteral.getValue(), hasToString("13.55"));
+ final RelDataTypeFactory typeFactoryHalfUp =
+ new SqlTypeFactoryImpl(new RelDataTypeSystemImpl() {
+ @Override public RoundingMode roundingMode() {
+ return RoundingMode.HALF_UP;
+ }
+ });
+ final RelDataType typeHalfUp =
+ typeFactoryHalfUp.createSqlType(SqlTypeName.DECIMAL, 4, 2);
+ final RexBuilder builderHalfUp = new RexBuilder(typeFactoryHalfUp);
+ RexLiteral rexLiteralHalfUp =
+ builderHalfUp.makeExactLiteral(new BigDecimal("13.556"), typeHalfUp);
+ assertThat(rexLiteralHalfUp.getValue() instanceof BigDecimal, is(true));
+ assertThat(rexLiteralHalfUp.getValue(), hasToString("13.56"));
+ }
+
+ @Test void testDecimalWithNegativeScaleRoundingHalfUp() {
+ final RelDataTypeFactory typeFactory =
+ new SqlTypeFactoryImpl(new RelDataTypeSystemImpl() {
+ @Override public int getMinScale(SqlTypeName typeName) {
+ switch (typeName) {
+ case DECIMAL:
+ return -2;
+ default:
+ return super.getMinScale(typeName);
+ }
+ }
+
+ @Override public RoundingMode roundingMode() {
+ return RoundingMode.HALF_UP;
+ }
+ });
+ final RelDataType type = typeFactory.createSqlType(SqlTypeName.DECIMAL, 3, -2);
+ final RexBuilder builder = new RexBuilder(typeFactory);
+ RexLiteral rexLiteral = builder.makeLiteral(new BigDecimal("12355"), type);
+ assertThat(rexLiteral.getValue() instanceof BigDecimal, is(true));
+ assertThat(rexLiteral.getValue(), hasToString("12400"));
+ }
+
+ @Test void testDecimalWithNegativeScaleRoundingDown() {
+ final RelDataTypeFactory typeFactory =
+ new SqlTypeFactoryImpl(
+ CustomTypeSystems.withMinScale(RelDataTypeSystem.DEFAULT,
+ typeName -> -2));
+ final RelDataType type = typeFactory.createSqlType(SqlTypeName.DECIMAL, 3, -2);
+ final RexBuilder builder = new RexBuilder(typeFactory);
+ RexLiteral rexLiteralHalfUp = builder.makeLiteral(new BigDecimal("12355"), type);
+ assertThat(rexLiteralHalfUp.getValue() instanceof BigDecimal, is(true));
+ assertThat(rexLiteralHalfUp.getValue(), hasToString("12300"));
+ }
+
/** Tests {@link DateString} year range. */
@Test void testDateStringYearError() {
try {
diff --git a/core/src/test/java/org/apache/calcite/sql/type/RelDataTypeSystemTest.java b/core/src/test/java/org/apache/calcite/sql/type/RelDataTypeSystemTest.java
index 57e691f3a0..c0c06820c9 100644
--- a/core/src/test/java/org/apache/calcite/sql/type/RelDataTypeSystemTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/type/RelDataTypeSystemTest.java
@@ -35,6 +35,8 @@ import org.junit.jupiter.api.Test;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
/**
* Tests the inference of return types using {@code RelDataTypeSystem}.
@@ -142,6 +144,30 @@ class RelDataTypeSystemTest {
final SqlTypeFactoryImpl customTypeFactory = new SqlTypeFactoryImpl(new CustomTypeSystem());
}
+ @Test void testNegativeScale() {
+ final SqlTypeFactoryImpl customTypeFactory =
+ new SqlTypeFactoryImpl(new RelDataTypeSystemImpl() {
+ @Override public int getMinScale(SqlTypeName typeName) {
+ switch (typeName) {
+ case DECIMAL:
+ return -10;
+ default:
+ return super.getMinScale(typeName);
+ }
+ }
+ });
+ RelDataType dataType = customTypeFactory.createSqlType(SqlTypeName.DECIMAL, 10, -5);
+ assertEquals(SqlTypeName.DECIMAL, dataType.getSqlTypeName());
+ assertEquals(10, dataType.getPrecision());
+ assertEquals(-5, dataType.getScale());
+ assertThrows(CalciteException.class, () ->
+ customTypeFactory.createSqlType(SqlTypeName.DECIMAL, 10, -11),
+ "DECIMAL scale -11 must be between -10 and 19");
+ assertThrows(CalciteException.class, () ->
+ new Fixture().typeFactory.createSqlType(SqlTypeName.DECIMAL, 10, -5),
+ "DECIMAL scale -11 must be between 0 and 19");
+ }
+
@Test void testDecimalAdditionReturnTypeInference() {
final SqlTypeFactoryImpl f = new Fixture().typeFactory;
RelDataType operand1 = f.createSqlType(SqlTypeName.DECIMAL, 10, 1);
diff --git a/core/src/test/java/org/apache/calcite/test/CoreQuidemTest.java b/core/src/test/java/org/apache/calcite/test/CoreQuidemTest.java
index 5b325e1a54..e7a3c636ab 100644
--- a/core/src/test/java/org/apache/calcite/test/CoreQuidemTest.java
+++ b/core/src/test/java/org/apache/calcite/test/CoreQuidemTest.java
@@ -26,6 +26,8 @@ import net.hydromatic.quidem.Quidem;
import java.sql.Connection;
import java.util.Collection;
+import static org.apache.calcite.util.Util.discard;
+
/**
* Test that runs every Quidem file in the "core" module as a test.
*/
@@ -69,12 +71,34 @@ class CoreQuidemTest extends QuidemTest {
.with(CalciteAssert.Config.SCOTT)
.connect();
case "scott-rounding-half-up":
+ discard(CustomTypeSystems.ROUNDING_MODE_HALF_UP);
+ return CalciteAssert.that()
+ .with(CalciteConnectionProperty.PARSER_FACTORY,
+ ExtensionDdlExecutor.class.getName() + "#PARSER_FACTORY")
+ .with(CalciteConnectionProperty.FUN, SqlLibrary.CALCITE.fun)
+ .with(CalciteConnectionProperty.TYPE_SYSTEM,
+ CustomTypeSystems.class.getName() + "#ROUNDING_MODE_HALF_UP")
+ .with(CalciteAssert.Config.SCOTT)
+ .connect();
+ case "scott-negative-scale":
+ discard(CustomTypeSystems.NEGATIVE_SCALE);
+ return CalciteAssert.that()
+ .with(CalciteConnectionProperty.PARSER_FACTORY,
+ ExtensionDdlExecutor.class.getName() + "#PARSER_FACTORY")
+ .with(CalciteConnectionProperty.FUN, SqlLibrary.CALCITE.fun)
+ .with(CalciteConnectionProperty.TYPE_SYSTEM,
+ CustomTypeSystems.class.getName() + "#NEGATIVE_SCALE")
+ .with(CalciteAssert.Config.SCOTT)
+ .connect();
+ case "scott-negative-scale-rounding-half-up":
+ discard(CustomTypeSystems.NEGATIVE_SCALE_ROUNDING_MODE_HALF_UP);
return CalciteAssert.that()
.with(CalciteConnectionProperty.PARSER_FACTORY,
ExtensionDdlExecutor.class.getName() + "#PARSER_FACTORY")
.with(CalciteConnectionProperty.FUN, SqlLibrary.CALCITE.fun)
.with(CalciteConnectionProperty.TYPE_SYSTEM,
- CustomRelDataTypeSystem.class.getName() + "#ROUNDING_MODE_HALF_UP")
+ CustomTypeSystems.class.getName()
+ + "#NEGATIVE_SCALE_ROUNDING_MODE_HALF_UP")
.with(CalciteAssert.Config.SCOTT)
.connect();
case "scott-lenient":
diff --git a/core/src/test/java/org/apache/calcite/test/CustomRelDataTypeSystem.java b/core/src/test/java/org/apache/calcite/test/CustomRelDataTypeSystem.java
deleted file mode 100644
index a230d18ae4..0000000000
--- a/core/src/test/java/org/apache/calcite/test/CustomRelDataTypeSystem.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to you under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.calcite.test;
-
-import org.apache.calcite.rel.type.RelDataTypeSystem;
-import org.apache.calcite.rel.type.RelDataTypeSystemImpl;
-
-import java.math.RoundingMode;
-
-/**
- * Custom type system only for Quidem test.
- *
- * <p> Specify the rounding behaviour. In the default implementation,
- * the rounding mode is {@link RoundingMode#DOWN}, but here is {@link RoundingMode#HALF_UP}
- *
- * <p>The default implementation is {@link #DEFAULT}.
- */
-
-public class CustomRelDataTypeSystem extends RelDataTypeSystemImpl {
-
- public static final RelDataTypeSystem ROUNDING_MODE_HALF_UP = new CustomRelDataTypeSystem();
-
- @Override public RoundingMode roundingMode() {
- return RoundingMode.HALF_UP;
- }
-}
diff --git a/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java b/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java
index 96f7d5c748..6c7c75e79b 100644
--- a/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java
+++ b/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java
@@ -2295,12 +2295,12 @@ public class SqlValidatorTest extends SqlValidatorTestCase {
fixture().factory.getTypeFactory().getTypeSystem();
final RelDataTypeSystem defTypeSystem = RelDataTypeSystem.DEFAULT;
for (SqlTypeName typeName : SqlTypeName.INTERVAL_TYPES) {
- assertThat(typeName.getMinPrecision(), is(1));
+ assertThat(typeSystem.getMinPrecision(typeName), is(1));
assertThat(typeSystem.getMaxPrecision(typeName), is(10));
assertThat(typeSystem.getDefaultPrecision(typeName), is(2));
- assertThat(typeName.getMinScale(), is(0));
+ assertThat(typeSystem.getMinScale(typeName), is(0));
assertThat(typeSystem.getMaxScale(typeName), is(9));
- assertThat(typeName.getDefaultScale(), is(6));
+ assertThat(typeSystem.getDefaultScale(typeName), is(6));
}
final SqlValidatorFixture f = fixture();
diff --git a/core/src/test/resources/sql/cast.iq b/core/src/test/resources/sql/cast.iq
index a24e1a4234..18198eaf82 100644
--- a/core/src/test/resources/sql/cast.iq
+++ b/core/src/test/resources/sql/cast.iq
@@ -1234,4 +1234,385 @@ EnumerableCalc(expr#0..7=[{inputs}], expr#8=[CAST($t6):INTEGER], expr#9=[IS NOT
EnumerableTableScan(table=[[scott, EMP]])
!plan
+# [CALCITE-6560] Add supportsNegativeScale in RelDataTypeSystem
+
+!use scott-negative-scale
+
+# supports negative scale and the rounding mode is DOWN
+
+# throw an exception when CAST target decimal type has illegal precision and scale
+
+# precision is 0
+values cast(15.3 as decimal(0, 4));
+DECIMAL precision 0 must be between 1 and 19
+!error
+
+# Same as previous; the number is 0
+values cast(0 as decimal(0,0));
+DECIMAL precision 0 must be between 1 and 19
+!error
+
+# scale greater than precision
+values cast(0 as decimal(3, 4));
++--------+
+| EXPR$0 |
++--------+
+| 0.0000 |
++--------+
+(1 row)
+
+!ok
+
+# Same as previous; the number is 1
+select cast(1 as decimal(3, 4));
+Value 1 cannot be represented as a DECIMAL(3, 4)
+!error
+
+# test the maximum value that can be stored
+select cast(99999 as decimal(2, -3));
++--------+
+| EXPR$0 |
++--------+
+| 99000 |
++--------+
+(1 row)
+
+!ok
+
+# Same as previous; the value is minimum value -99999
+select cast(-99999 as decimal(2, -3));
++--------+
+| EXPR$0 |
++--------+
+| -99000 |
++--------+
+(1 row)
+
+!ok
+
+# Same as previous; the value is 100000
+select cast(100000 as decimal(2, -3));
+Value 100000 cannot be represented as a DECIMAL(2, -3)
+!error
+
+# Same as previous; the value is -100000
+select cast(-100000 as decimal(2, -3));
+Value -100000 cannot be represented as a DECIMAL(2, -3)
+!error
+
+# Test cast integer to decimal with negative scale
+
+# The non-rounded digits greater than the precision represents the maximum value
+select cast(12340 as decimal(3, -1));
+Value 12340 cannot be represented as a DECIMAL(3, -1)
+!error
+
+# The precision represents the maximum value greater than the number
+select cast(12340 as decimal(6, -1));
++--------+
+| EXPR$0 |
++--------+
+| 12340 |
++--------+
+(1 row)
+
+!ok
+
+# Same as previous; the precision is 5
+select cast(12340 as decimal(5, -1));
++--------+
+| EXPR$0 |
++--------+
+| 12340 |
++--------+
+(1 row)
+
+!ok
+
+# Same as previous; the precision is 4
+select cast(12340 as decimal(4, -1));
++--------+
+| EXPR$0 |
++--------+
+| 12340 |
++--------+
+(1 row)
+
+!ok
+
+# Test the negative scale that can be represents
+select cast(12340 as decimal(3, -2));
++--------+
+| EXPR$0 |
++--------+
+| 12300 |
++--------+
+(1 row)
+
+!ok
+
+select cast(12340 as decimal(4, -1));
++--------+
+| EXPR$0 |
++--------+
+| 12340 |
++--------+
+(1 row)
+
+!ok
+
+select cast(12340 as decimal(5, -3));
++--------+
+| EXPR$0 |
++--------+
+| 12000 |
++--------+
+(1 row)
+
+!ok
+
+# Same as previous; the scale equal with -precision
+select cast(12340 as decimal(5, -5));
++--------+
+| EXPR$0 |
++--------+
+| 0 |
++--------+
+(1 row)
+
+!ok
+
+# Same as previous; the -scale greater than precision
+select cast(12340 as decimal(5, -6));
++--------+
+| EXPR$0 |
++--------+
+| 0 |
++--------+
+(1 row)
+
+!ok
+
+# Cast a decimal literal to a decimal with negative scale
+
+values cast(153.3 as decimal(3, -1));
++--------+
+| EXPR$0 |
++--------+
+| 150 |
++--------+
+(1 row)
+
+!ok
+
+values cast(153.3 as decimal(1, -1));
+Value 153.3 cannot be represented as a DECIMAL(1, -1)
+!error
+
+# the rounding mode is DOWN
+values cast(156.6 as decimal(3, -1));
++--------+
+| EXPR$0 |
++--------+
+| 150 |
++--------+
+(1 row)
+
+!ok
+
+# Cast a character literal to a decimal with negative scale
+
+values cast(' 153.3 ' as decimal(3, -1));
++--------+
+| EXPR$0 |
++--------+
+| 150 |
++--------+
+(1 row)
+
+!ok
+
+values cast(' 153.3 ' as decimal(1, -1));
+Value 153.3 cannot be represented as a DECIMAL(1, -1)
+!error
+
+# the rounding mode is DOWN
+values cast(' 156.6 ' as decimal(3, -1));
++--------+
+| EXPR$0 |
++--------+
+| 150 |
++--------+
+(1 row)
+
+!ok
+
+# Cast a double literal to a decimal with negative scale
+
+values cast(cast(153.3 as double) as decimal(3, -1));
++--------+
+| EXPR$0 |
++--------+
+| 150 |
++--------+
+(1 row)
+
+!ok
+
+values cast(cast(153.3 as double) as decimal(1, -1));
+Value 153.3 cannot be represented as a DECIMAL(1, -1)
+!error
+
+values cast(cast(156.3 as double) as decimal(3, -1));
++--------+
+| EXPR$0 |
++--------+
+| 150 |
++--------+
+(1 row)
+
+!ok
+
+# Cast a float literal to a decimal with negative scale
+
+values cast(cast(153.3 as float) as decimal(3, -1));
++--------+
+| EXPR$0 |
++--------+
+| 150 |
++--------+
+(1 row)
+
+!ok
+
+values cast(cast(153.3 as float) as decimal(1, -1));
+Value 153.3 cannot be represented as a DECIMAL(1, -1)
+!error
+
+values cast(cast(156.3 as float) as decimal(3, -1));
++--------+
+| EXPR$0 |
++--------+
+| 150 |
++--------+
+(1 row)
+
+!ok
+
+# Cast a real literal to a decimal
+
+values cast(cast(153.3 as real) as decimal(3, -1));
++--------+
+| EXPR$0 |
++--------+
+| 150 |
++--------+
+(1 row)
+
+!ok
+
+values cast(cast(153.3 as real) as decimal(1, -1));
+Value 153.3000030517578 cannot be represented as a DECIMAL(1, -1)
+!error
+
+values cast(cast(156.3 as real) as decimal(3, -1));
++--------+
+| EXPR$0 |
++--------+
+| 150 |
++--------+
+(1 row)
+
+!ok
+
+!use scott-negative-scale-rounding-half-up
+
+# supports negative scale and the rounding mode is HALF UP
+
+# test maximum value that can be stored, the rounding mode is HALF UP
+select cast(99999 as decimal(2, -3));
+Value 99999 cannot be represented as a DECIMAL(2, -3)
+!error
+
+select cast(99499 as decimal(2, -3));
++--------+
+| EXPR$0 |
++--------+
+| 99000 |
++--------+
+(1 row)
+
+!ok
+
+# Same as previous; the number is -99999
+select cast(-99999 as decimal(2, -3));
+Value -99999 cannot be represented as a DECIMAL(2, -3)
+!error
+
+# Same as previous; the number is -99499
+select cast(-99499 as decimal(2, -3));
++--------+
+| EXPR$0 |
++--------+
+| -99000 |
++--------+
+(1 row)
+
+!ok
+
+# Cast a double literal to a decimal with negative scale
+values cast(156.6 as decimal(3, -1));
++--------+
+| EXPR$0 |
++--------+
+| 160 |
++--------+
+(1 row)
+
+!ok
+
+# Cast a char literal to a decimal with negative scale
+values cast(' 156.6 ' as decimal(3, -1));
++--------+
+| EXPR$0 |
++--------+
+| 160 |
++--------+
+(1 row)
+
+!ok
+
+# Cast a float literal to a decimal with negative scale
+values cast(cast(156.6 as float) as decimal(3, -1));
++--------+
+| EXPR$0 |
++--------+
+| 160 |
++--------+
+(1 row)
+
+!ok
+
+# Cast a double literal to a decimal with negative scale
+values cast(cast(156.6 as double) as decimal(3, -1));
++--------+
+| EXPR$0 |
++--------+
+| 160 |
++--------+
+(1 row)
+
+!ok
+
+# Cast a real literal to a decimal with negative scale
+values cast(cast(156.6 as real) as decimal(3, -1));
++--------+
+| EXPR$0 |
++--------+
+| 160 |
++--------+
+(1 row)
+
+!ok
+
# End cast.iq
diff --git a/linq4j/src/main/java/org/apache/calcite/linq4j/tree/Primitive.java b/linq4j/src/main/java/org/apache/calcite/linq4j/tree/Primitive.java
index 34f40e83f6..926edf9210 100644
--- a/linq4j/src/main/java/org/apache/calcite/linq4j/tree/Primitive.java
+++ b/linq4j/src/main/java/org/apache/calcite/linq4j/tree/Primitive.java
@@ -410,6 +410,11 @@ public enum Primitive {
throw new ArithmeticException("Value " + value
+ " cannot be represented as a DECIMAL(" + precision + ", " + scale + ")");
}
+ if (scale < 0) {
+ // The result maybe scientific notation string,e.g. 1.234E+6,
+ // we need to convert it to 1234000
+ return new BigDecimal(result.toPlainString());
+ }
return result;
}
diff --git a/testkit/src/main/java/org/apache/calcite/sql/parser/SqlParserTest.java b/testkit/src/main/java/org/apache/calcite/sql/parser/SqlParserTest.java
index 6e4c86f0ec..9e4734b939 100644
--- a/testkit/src/main/java/org/apache/calcite/sql/parser/SqlParserTest.java
+++ b/testkit/src/main/java/org/apache/calcite/sql/parser/SqlParserTest.java
@@ -1014,6 +1014,30 @@ public class SqlParserTest {
.ok("SELECT 999");
}
+ @Test void testDecimalWithScale() {
+ sql("select cast(15 as decimal(3, 1))")
+ .ok("SELECT CAST(15 AS DECIMAL(3, 1))");
+ sql("select cast(15 as decimal(3, -1))")
+ .ok("SELECT CAST(15 AS DECIMAL(3, -1))");
+ sql("select cast(15 as decimal(3, 0))")
+ .ok("SELECT CAST(15 AS DECIMAL(3, 0))");
+ }
+
+ @Test void testDecimalWithPrecision() {
+ // the precision greater than the max precision
+ sql("select cast(15 as decimal(1000, 1))")
+ .ok("SELECT CAST(15 AS DECIMAL(1000, 1))");
+ sql("select cast(15 as decimal(3, 1))")
+ .ok("SELECT CAST(15 AS DECIMAL(3, 1))");
+ sql("select cast(15 as decimal(^-^3, 1))")
+ .fails("Encountered \"-\" at line 1, column 27\\.\n"
+ + "Was expecting:\n"
+ + " <UNSIGNED_INTEGER_LITERAL> \\.\\.\\.\n"
+ + " ");
+ sql("select cast(15 as decimal(0, 0))")
+ .ok("SELECT CAST(15 AS DECIMAL(0, 0))");
+ }
+
@Test void testDerivedColumnList() {
sql("select * from emp as e (empno, gender) where true")
.ok("SELECT *\n"
diff --git a/testkit/src/main/java/org/apache/calcite/test/CustomTypeSystems.java b/testkit/src/main/java/org/apache/calcite/test/CustomTypeSystems.java
new file mode 100644
index 0000000000..6df9bbdf55
--- /dev/null
+++ b/testkit/src/main/java/org/apache/calcite/test/CustomTypeSystems.java
@@ -0,0 +1,96 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.test;
+
+import org.apache.calcite.rel.type.DelegatingTypeSystem;
+import org.apache.calcite.rel.type.RelDataTypeSystem;
+import org.apache.calcite.sql.type.SqlTypeName;
+
+import java.math.RoundingMode;
+import java.util.function.Function;
+
+/**
+ * Custom implementations of {@link RelDataTypeSystem} for testing.
+ */
+@SuppressWarnings("SameParameterValue")
+public final class CustomTypeSystems {
+ private CustomTypeSystems() {
+ }
+
+ /** Type system with rounding behavior {@link RoundingMode#HALF_UP}.
+ * (The default implementation is {@link RoundingMode#DOWN}.) */
+ public static final RelDataTypeSystem ROUNDING_MODE_HALF_UP =
+ withRoundingMode(RelDataTypeSystem.DEFAULT, RoundingMode.HALF_UP);
+
+ /** Type system that supports negative scale
+ * and has rounding mode {@link RoundingMode#DOWN}. */
+ public static final RelDataTypeSystem NEGATIVE_SCALE =
+ withMinScale(RelDataTypeSystem.DEFAULT, sqlTypeName -> -1000);
+
+ /** Type system that supports negative scale
+ * and has rounding mode {@link RoundingMode#HALF_UP}. */
+ public static final RelDataTypeSystem NEGATIVE_SCALE_ROUNDING_MODE_HALF_UP =
+ withMinScale(ROUNDING_MODE_HALF_UP, sqlTypeName -> -1000);
+
+ /** Decorates a type system so that
+ * {@link org.apache.calcite.rel.type.RelDataTypeSystem#roundingMode()}
+ * returns a given value. */
+ public static RelDataTypeSystem withRoundingMode(RelDataTypeSystem typeSystem,
+ RoundingMode roundingMode) {
+ return new DelegatingTypeSystem(typeSystem) {
+ @Override public RoundingMode roundingMode() {
+ return roundingMode;
+ }
+ };
+ }
+
+ /** Decorates a type system so that
+ * {@link org.apache.calcite.rel.type.RelDataTypeSystem#getMaxPrecision(SqlTypeName)}
+ * returns a given value. */
+ public static RelDataTypeSystem withMaxPrecision(RelDataTypeSystem typeSystem,
+ Function<SqlTypeName, Integer> maxPrecision) {
+ return new DelegatingTypeSystem(typeSystem) {
+ @Override public int getMaxPrecision(SqlTypeName typeName) {
+ return maxPrecision.apply(typeName);
+ }
+ };
+ }
+
+ /** Decorates a type system so that
+ * {@link org.apache.calcite.rel.type.RelDataTypeSystem#getMaxScale(SqlTypeName)}
+ * returns a given value. */
+ public static RelDataTypeSystem withMaxScale(RelDataTypeSystem typeSystem,
+ Function<SqlTypeName, Integer> maxScale) {
+ return new DelegatingTypeSystem(typeSystem) {
+ @Override public int getMaxScale(SqlTypeName typeName) {
+ return maxScale.apply(typeName);
+ }
+ };
+ }
+
+ /** Decorates a type system so that
+ * {@link org.apache.calcite.rel.type.RelDataTypeSystem#getMinScale(SqlTypeName)}
+ * returns a given value. */
+ public static RelDataTypeSystem withMinScale(RelDataTypeSystem typeSystem,
+ Function<SqlTypeName, Integer> minNumericScale) {
+ return new DelegatingTypeSystem(typeSystem) {
+ @Override public int getMinScale(SqlTypeName typeName) {
+ return minNumericScale.apply(typeName);
+ }
+ };
+ }
+}
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 7337ebe490..a51779223a 100644
--- a/testkit/src/main/java/org/apache/calcite/test/SqlOperatorTest.java
+++ b/testkit/src/main/java/org/apache/calcite/test/SqlOperatorTest.java
@@ -1701,6 +1701,47 @@ public class SqlOperatorTest {
}
}
+ @Test void testCastToDecimal() {
+ final SqlOperatorFixture f = fixture();
+ // test the minimum scale is 0
+ f.setFor(SqlStdOperatorTable.CAST, VmName.EXPAND);
+ // cast integer to decimal
+ f.checkFails("cast(123 as decimal(3, -1))",
+ "DECIMAL scale -1 must be between 0 and 19", false);
+ // cast float to decimal
+ f.checkFails("cast(12.3 as decimal(3, -1))",
+ "DECIMAL scale -1 must be between 0 and 19", false);
+ // cast decimal to decimal
+ f.checkFails("cast(cast(12.3 as decimal(3, 1)) as decimal(3, -1))",
+ "DECIMAL scale -1 must be between 0 and 19", false);
+ // cast string to decimal
+ f.checkFails("cast('12.3' as decimal(3, -1))",
+ "DECIMAL scale -1 must be between 0 and 19", false);
+ // cast interval to decimal
+ f.checkFails("cast(INTERVAL '5' hour as decimal(3, -1))",
+ "DECIMAL scale -1 must be between 0 and 19", false);
+ // test the minimum scale is -2
+ final SqlOperatorFixture negativeScaleFixture = fixture()
+ .withFactory(tf ->
+ tf.withTypeSystem(typeSystem ->
+ CustomTypeSystems.withMinScale(typeSystem, typeName -> -2)));
+ // cast integer to decimal
+ negativeScaleFixture.checkScalar("cast(123 as decimal(3, -1))",
+ "120", "DECIMAL(3, -1) NOT NULL");
+ // cast float to decimal
+ negativeScaleFixture.checkScalar("cast(12.3 as decimal(3, -1))",
+ "10", "DECIMAL(3, -1) NOT NULL");
+ // cast decimal to decimal
+ negativeScaleFixture.checkScalar("cast(cast(12.3 as decimal(3, 1)) as decimal(3, -1))",
+ "10", "DECIMAL(3, -1) NOT NULL");
+ // cast string to decimal
+ negativeScaleFixture.checkScalar("cast('12.3' as decimal(3, -1))",
+ "10", "DECIMAL(3, -1) NOT NULL");
+ // cast interval to decimal
+ negativeScaleFixture.checkScalar("cast(INTERVAL '5' hour as decimal(3, -1))",
+ "0", "DECIMAL(3, -1) NOT NULL");
+ }
+
@Test void testCastRowType() {
final SqlOperatorFixture f = fixture();
f.checkScalar("cast((1, 2) as row(f0 integer, f1 bigint))",