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:40:00 UTC
(calcite) 01/02: Refactor: Migrate from assertEquals to assertThat
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 ...