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 ...