You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@druid.apache.org by al...@apache.org on 2026/08/08 17:07:47 UTC

(druid) branch master updated: test(sql): migrate SQL leaf and Quidem tests to JUnit 5 (#19909)

This is an automated email from the ASF dual-hosted git repository.

AlbericByte pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/druid.git


The following commit(s) were added to refs/heads/master by this push:
     new b1b968365de test(sql): migrate SQL leaf and Quidem tests to JUnit 5 (#19909)
b1b968365de is described below

commit b1b968365de241f557a679634f125741424907fd
Author: Frank Chen <fr...@outlook.com>
AuthorDate: Sun Aug 9 01:07:41 2026 +0800

    test(sql): migrate SQL leaf and Quidem tests to JUnit 5 (#19909)
    
    * test(sql): migrate SQL leaf and Quidem tests to JUnit 5
    
    * style(sql): tidy Hamcrest assertion import
    
    * test(sql): remove unused parameterized arguments
    
    * test(sql,server): migrate shared QueryStackTests to JUnit 5
    
    * test: use JUnit 5 parameterized classes
---
 quidem-ut/pom.xml                                  |  13 +-
 .../org/apache/druid/quidem/LauncherSmokeTest.java |  17 +-
 .../CachingClusteredClientFunctionalityTest.java   |  21 +-
 .../druid/client/CachingClusteredClientTest.java   |  81 +++--
 .../apache/druid/client/DirectDruidClientTest.java | 141 ++++----
 .../SegmentMetadataQuerySegmentWalkerTest.java     |  20 +-
 .../org/apache/druid/server/QueryStackTests.java   |  15 +-
 .../druid/quidem/DruidAvaticaDriverTest.java       |   4 +-
 .../druid/quidem/DruidQuidemCommandHandler.java    |   4 +-
 .../apache/druid/quidem/DruidQuidemTestBase.java   |   8 +-
 .../apache/druid/sql/SqlLifecycleManagerTest.java  |  34 +-
 .../org/apache/druid/sql/SqlQueryPlusTest.java     |  18 +-
 .../apache/druid/sql/SqlRowTransformerTest.java    |   8 +-
 .../org/apache/druid/sql/SqlStatementTest.java     |  69 ++--
 .../druid/sql/avatica/AvaticaModuleTest.java       |  86 ++---
 .../druid/sql/avatica/DruidAvaticaHandlerTest.java | 262 +++++++-------
 .../druid/sql/avatica/DruidStatementTest.java      |  84 ++---
 .../apache/druid/sql/avatica/ErrorHandlerTest.java |  14 +-
 .../aggregation/SqlAggregationModuleTest.java      |  13 +-
 .../calcite/expression/DruidExpressionTest.java    | 110 +++---
 .../calcite/expression/ExpressionTestHelper.java   |  21 +-
 .../sql/calcite/expression/ExpressionsTest.java    |  25 +-
 .../expression/IPv4AddressMatchExpressionTest.java |  18 +-
 .../expression/IPv4AddressParseExpressionTest.java |  10 +-
 .../IPv4AddressStringifyExpressionTest.java        |  10 +-
 .../expression/OperatorConversionsTest.java        | 145 ++++----
 .../external/ExternalTableScanRuleTest.java        |   6 +-
 .../filtration/CombineAndSimplifyBoundsTest.java   |   2 +-
 .../sql/calcite/filtration/FiltrationTest.java     |   6 +-
 .../druid/sql/calcite/http/SqlQueryTest.java       |   8 +-
 .../sql/calcite/parser/DruidSqlParserTest.java     |  52 +--
 .../calcite/parser/DruidSqlParserUtilsTest.java    |  87 ++---
 .../sql/calcite/parser/DruidSqlUnparseTest.java    |   4 +-
 .../calcite/planner/CalcitePlannerModuleTest.java  |  17 +-
 .../sql/calcite/planner/ColumnMappingTest.java     |   2 +-
 .../sql/calcite/planner/ColumnMappingsTest.java    |   2 +-
 .../druid/sql/calcite/planner/DruidHintTest.java   |  14 +-
 .../calcite/planner/DruidOperatorTableTest.java    |  44 +--
 .../sql/calcite/planner/DruidRexExecutorTest.java  |  48 +--
 .../druid/sql/calcite/planner/OffsetLimitTest.java |  22 +-
 .../sql/calcite/planner/PlannerConfigTest.java     |  18 +-
 .../druid/sql/calcite/planner/TrivialTest.java     |   4 +-
 .../druid/sql/calcite/rel/DruidQueryTest.java      |  10 +-
 .../apache/druid/sql/calcite/rel/DruidRelTest.java |  42 +--
 .../druid/sql/calcite/rel/DruidRelsTest.java       |  73 ++--
 .../apache/druid/sql/calcite/rel/GroupingTest.java |   2 +-
 .../druid/sql/calcite/rule/DruidJoinRuleTest.java  |  32 +-
 .../calcite/rule/DruidLogicalValuesRuleTest.java   |  99 +++--
 .../calcite/rule/DruidUnionDataSourceRuleTest.java |  22 +-
 .../rule/FilterDecomposeConcatRuleTest.java        |  42 +--
 .../rule/FilterJoinExcludePushToChildRuleTest.java |  16 +-
 .../druid/sql/calcite/run/DruidHookTest.java       |   2 +-
 .../druid/sql/calcite/run/SqlResultsTest.java      |  33 +-
 .../druid/sql/calcite/util/SqlTestFramework.java   |   1 +
 .../sql/destination/ExportDestinationTest.java     |   6 +-
 .../sql/destination/TableDestinationTest.java      |   6 +-
 .../org/apache/druid/sql/guice/SqlModuleTest.java  |  23 +-
 .../apache/druid/sql/http/ResultFormatTest.java    |  14 +-
 .../apache/druid/sql/http/SqlHttpModuleTest.java   |  22 +-
 .../org/apache/druid/sql/http/SqlQueryTest.java    |  93 ++---
 .../org/apache/druid/sql/http/SqlResourceTest.java | 398 ++++++++++-----------
 61 files changed, 1264 insertions(+), 1259 deletions(-)

diff --git a/quidem-ut/pom.xml b/quidem-ut/pom.xml
index b936d54169a..82c2352d0c8 100644
--- a/quidem-ut/pom.xml
+++ b/quidem-ut/pom.xml
@@ -449,19 +449,10 @@
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter</artifactId>
         </dependency>
-        <dependency>
-            <groupId>org.junit.vintage</groupId>
-            <artifactId>junit-vintage-engine</artifactId>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-api</artifactId>
         </dependency>
-        <dependency>
-            <groupId>junit</groupId>
-            <artifactId>junit</artifactId>
-        </dependency>
         <dependency>
             <groupId>org.apache.calcite.avatica</groupId>
             <artifactId>avatica</artifactId>
@@ -494,12 +485,12 @@
         <dependency>
             <groupId>org.hamcrest</groupId>
             <artifactId>hamcrest</artifactId>
-            <scope>compile</scope>
+            <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>org.hamcrest</groupId>
             <artifactId>hamcrest-core</artifactId>
-            <scope>compile</scope>
+            <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>org.mockito</groupId>
diff --git a/quidem-ut/src/test/java/org/apache/druid/quidem/LauncherSmokeTest.java b/quidem-ut/src/test/java/org/apache/druid/quidem/LauncherSmokeTest.java
index 6402cd63e43..5e726da1182 100644
--- a/quidem-ut/src/test/java/org/apache/druid/quidem/LauncherSmokeTest.java
+++ b/quidem-ut/src/test/java/org/apache/druid/quidem/LauncherSmokeTest.java
@@ -26,26 +26,25 @@ import org.apache.http.entity.StringEntity;
 import org.apache.http.impl.client.CloseableHttpClient;
 import org.apache.http.impl.client.HttpClients;
 import org.apache.http.util.EntityUtils;
-import org.hamcrest.MatcherAssert;
-import org.hamcrest.Matchers;
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class LauncherSmokeTest
 {
   private static Launcher launcher;
 
-  @BeforeClass
+  @BeforeAll
   public static void setUp() throws Exception
   {
     launcher = new Launcher("druidtest:///");
     launcher.start();
   }
 
-  @AfterClass
+  @AfterAll
   public static void tearDown()
   {
     launcher.shutdown();
@@ -71,6 +70,6 @@ public class LauncherSmokeTest
     CloseableHttpResponse response = client.execute(request);
     assertEquals(200, response.getStatusLine().getStatusCode());
     String responseStr = EntityUtils.toString(response.getEntity());
-    MatcherAssert.assertThat(responseStr, Matchers.containsString("\"version\":\""));
+    Assertions.assertTrue(responseStr.contains("\"version\":\""));
   }
 }
diff --git a/server/src/test/java/org/apache/druid/client/CachingClusteredClientFunctionalityTest.java b/server/src/test/java/org/apache/druid/client/CachingClusteredClientFunctionalityTest.java
index 81d997c19fd..7fd831de9f7 100644
--- a/server/src/test/java/org/apache/druid/client/CachingClusteredClientFunctionalityTest.java
+++ b/server/src/test/java/org/apache/druid/client/CachingClusteredClientFunctionalityTest.java
@@ -54,12 +54,13 @@ import org.apache.druid.timeline.partition.NoneShardSpec;
 import org.apache.druid.timeline.partition.SingleElementPartitionChunk;
 import org.easymock.EasyMock;
 import org.joda.time.Interval;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.ClassRule;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
 
 import javax.annotation.Nullable;
+
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
@@ -80,10 +81,10 @@ public class CachingClusteredClientFunctionalityTest
   private TimelineServerView serverView;
   private Cache cache;
 
-  @ClassRule
-  public static QueryStackTests.Junit4ConglomerateRule conglomerateRule = new QueryStackTests.Junit4ConglomerateRule();
+  @RegisterExtension
+  public static QueryStackTests.ConglomerateExtension conglomerateRule = new QueryStackTests.ConglomerateExtension();
 
-  @Before
+  @BeforeEach
   public void setUp()
   {
     timeline = new VersionedIntervalTimeline<>(Ordering.natural());
@@ -115,7 +116,7 @@ public class CachingClusteredClientFunctionalityTest
 
     ResponseContext responseContext = ResponseContext.createEmpty();
     runQuery(client, builder.build(), responseContext);
-    Assert.assertNull(responseContext.getUncoveredIntervals());
+    Assertions.assertNull(responseContext.getUncoveredIntervals());
 
     builder.intervals("2015-01-01/2015-01-03");
     responseContext = ResponseContext.createEmpty();
@@ -164,8 +165,8 @@ public class CachingClusteredClientFunctionalityTest
     for (String interval : intervals) {
       expectedList.add(Intervals.of(interval));
     }
-    Assert.assertEquals(expectedList, context.getUncoveredIntervals());
-    Assert.assertEquals(uncoveredIntervalsOverflowed, context.get(ResponseContext.Keys.UNCOVERED_INTERVALS_OVERFLOWED));
+    Assertions.assertEquals(expectedList, context.getUncoveredIntervals());
+    Assertions.assertEquals(uncoveredIntervalsOverflowed, context.get(ResponseContext.Keys.UNCOVERED_INTERVALS_OVERFLOWED));
   }
 
   private void addToTimeline(Interval interval, String version)
diff --git a/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java b/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java
index 94c259314de..877f5ae1970 100644
--- a/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java
+++ b/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java
@@ -137,14 +137,15 @@ import org.joda.time.DateTime;
 import org.joda.time.DateTimeZone;
 import org.joda.time.Interval;
 import org.joda.time.Period;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.ClassRule;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import javax.annotation.Nullable;
+
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -166,7 +167,8 @@ import java.util.stream.IntStream;
 /**
  *
  */
-@RunWith(Parameterized.class)
+@ParameterizedClass(name = "{0}")
+@MethodSource("constructorFeeder")
 public class CachingClusteredClientTest
 {
   private static final ImmutableMap<String, Object> CONTEXT = ImmutableMap.of(
@@ -251,10 +253,11 @@ public class CachingClusteredClientTest
   private static final Granularity PT1H_TZ_GRANULARITY = new PeriodGranularity(new Period("PT1H"), null, TIMEZONE);
   private static final String TOP_DIM = "a_dim";
 
-  @ClassRule
-  public static QueryStackTests.Junit4ConglomerateRule conglomerateRule = new QueryStackTests.Junit4ConglomerateRule();
+  @RegisterExtension
+  public static QueryStackTests.ConglomerateExtension conglomerateRule = new QueryStackTests.ConglomerateExtension();
 
-  private final Random random;
+  private final int randomSeed;
+  private Random random;
 
   private CachingClusteredClient client;
   private Runnable queryCompletedCallback;
@@ -265,10 +268,9 @@ public class CachingClusteredClientTest
 
   public CachingClusteredClientTest(int randomSeed)
   {
-    this.random = new Random(randomSeed);
+    this.randomSeed = randomSeed;
   }
 
-  @Parameterized.Parameters(name = "{0}")
   public static Iterable<Object[]> constructorFeeder()
   {
     return Lists.transform(
@@ -284,9 +286,10 @@ public class CachingClusteredClientTest
     );
   }
 
-  @Before
+  @BeforeEach
   public void setUp()
   {
+    this.random = new Random(randomSeed);
     timeline = new VersionedIntervalTimeline<>(Ordering.natural());
     serverView = EasyMock.createNiceMock(TimelineServerView.class);
     cache = MapCache.create(100000);
@@ -557,8 +560,8 @@ public class CachingClusteredClientTest
 
     getDefaultQueryRunner().run(QueryPlus.wrap(query), context);
 
-    Assert.assertTrue("Capture cache keys", cacheKeyCapture.hasCaptured());
-    Assert.assertTrue("Cache key below limit", ImmutableList.copyOf(cacheKeyCapture.getValue()).size() <= limit);
+    Assertions.assertTrue(cacheKeyCapture.hasCaptured(), "Capture cache keys");
+    Assertions.assertTrue(ImmutableList.copyOf(cacheKeyCapture.getValue()).size() <= limit, "Cache key below limit");
 
     EasyMock.verify(cache);
 
@@ -572,8 +575,8 @@ public class CachingClusteredClientTest
     getDefaultQueryRunner().run(QueryPlus.wrap(query), context);
     EasyMock.verify(cache);
     EasyMock.verify(dataSegment);
-    Assert.assertTrue("Capture cache keys", cacheKeyCapture.hasCaptured());
-    Assert.assertTrue("Cache Keys empty", ImmutableList.copyOf(cacheKeyCapture.getValue()).isEmpty());
+    Assertions.assertTrue(cacheKeyCapture.hasCaptured(), "Capture cache keys");
+    Assertions.assertTrue(ImmutableList.copyOf(cacheKeyCapture.getValue()).isEmpty(), "Cache Keys empty");
   }
 
   @Test
@@ -704,9 +707,9 @@ public class CachingClusteredClientTest
         Intervals.of("2011-01-01/2011-01-02"), makeTimeResults(DateTimes.of("2011-01-01"), 50, 5000)
     );
 
-    Assert.assertEquals(1, cache.getStats().getNumEntries());
-    Assert.assertEquals(0, cache.getStats().getNumHits());
-    Assert.assertEquals(0, cache.getStats().getNumMisses());
+    Assertions.assertEquals(1, cache.getStats().getNumEntries());
+    Assertions.assertEquals(0, cache.getStats().getNumHits());
+    Assertions.assertEquals(0, cache.getStats().getNumMisses());
 
     cache.close(SegmentId.dummy("0_0").toString());
 
@@ -723,9 +726,9 @@ public class CachingClusteredClientTest
         Intervals.of("2011-01-01/2011-01-02"), makeTimeResults(DateTimes.of("2011-01-01"), 50, 5000)
     );
 
-    Assert.assertEquals(0, cache.getStats().getNumEntries());
-    Assert.assertEquals(0, cache.getStats().getNumHits());
-    Assert.assertEquals(0, cache.getStats().getNumMisses());
+    Assertions.assertEquals(0, cache.getStats().getNumEntries());
+    Assertions.assertEquals(0, cache.getStats().getNumHits());
+    Assertions.assertEquals(0, cache.getStats().getNumMisses());
 
     testQueryCaching(
         getDefaultQueryRunner(),
@@ -740,9 +743,9 @@ public class CachingClusteredClientTest
         Intervals.of("2011-01-01/2011-01-02"), makeTimeResults(DateTimes.of("2011-01-01"), 50, 5000)
     );
 
-    Assert.assertEquals(0, cache.getStats().getNumEntries());
-    Assert.assertEquals(0, cache.getStats().getNumHits());
-    Assert.assertEquals(1, cache.getStats().getNumMisses());
+    Assertions.assertEquals(0, cache.getStats().getNumEntries());
+    Assertions.assertEquals(0, cache.getStats().getNumHits());
+    Assertions.assertEquals(1, cache.getStats().getNumMisses());
   }
 
   @Test
@@ -1423,7 +1426,7 @@ public class CachingClusteredClientTest
 
     runner.run(QueryPlus.wrap(query)).toList();
 
-    Assert.assertEquals(expected, ((TimeseriesQuery) capture.getValue().getQuery()).getQuerySegmentSpec());
+    Assertions.assertEquals(expected, ((TimeseriesQuery) capture.getValue().getQuery()).getQuerySegmentSpec());
   }
 
   @Test
@@ -1598,7 +1601,7 @@ public class CachingClusteredClientTest
     MultipleSpecificSegmentSpec expected = new MultipleSpecificSegmentSpec(expcetedDescriptors);
 
     runner.run(QueryPlus.wrap(query)).toList();
-    Assert.assertEquals(expected, ((TimeseriesQuery) capture.getValue().getQuery()).getQuerySegmentSpec());
+    Assertions.assertEquals(expected, ((TimeseriesQuery) capture.getValue().getQuery()).getQuerySegmentSpec());
   }
 
   @Test
@@ -1717,11 +1720,11 @@ public class CachingClusteredClientTest
 
     runner.run(QueryPlus.wrap(query)).toList();
     QuerySegmentSpec querySegmentSpec = ((TimeseriesQuery) capture.getValue().getQuery()).getQuerySegmentSpec();
-    Assert.assertSame(MultipleSpecificSegmentSpec.class, querySegmentSpec.getClass());
+    Assertions.assertSame(MultipleSpecificSegmentSpec.class, querySegmentSpec.getClass());
     final Set<SegmentDescriptor> actualDescriptors = new HashSet<>(
         ((MultipleSpecificSegmentSpec) querySegmentSpec).getDescriptors()
     );
-    Assert.assertEquals(expcetedDescriptors, actualDescriptors);
+    Assertions.assertEquals(expcetedDescriptors, actualDescriptors);
   }
 
   private ServerSelector makeMockHashBasedSelector(
@@ -2163,9 +2166,9 @@ public class CachingClusteredClientTest
         Query capturedQuery = capturedQueryPlus.getQuery();
         final QueryContext queryContext = capturedQuery.context();
         if (expectBySegment) {
-          Assert.assertEquals(true, queryContext.getBoolean(QueryContexts.BY_SEGMENT_KEY));
+          Assertions.assertEquals(true, queryContext.getBoolean(QueryContexts.BY_SEGMENT_KEY));
         } else {
-          Assert.assertTrue(
+          Assertions.assertTrue(
               queryContext.get(QueryContexts.BY_SEGMENT_KEY) == null ||
               !queryContext.getBoolean(QueryContexts.BY_SEGMENT_KEY)
           );
@@ -3050,7 +3053,7 @@ public class CachingClusteredClientTest
     final ResponseContext responseContext = initializeResponseContext();
 
     getDefaultQueryRunner().run(QueryPlus.wrap(query), responseContext);
-    Assert.assertEquals("RsQmZHYstvXNeGf86z3pgpk+Wsg=", responseContext.getEntityTag());
+    Assertions.assertEquals("RsQmZHYstvXNeGf86z3pgpk+Wsg=", responseContext.getEntityTag());
   }
 
   @Test
@@ -3102,7 +3105,7 @@ public class CachingClusteredClientTest
     final String etag1 = responseContext.getEntityTag();
     getDefaultQueryRunner().run(QueryPlus.wrap(query2), responseContext);
     final String etag2 = responseContext.getEntityTag();
-    Assert.assertNotEquals(etag1, etag2);
+    Assertions.assertNotEquals(etag1, etag2);
   }
 
   @Test
@@ -3163,9 +3166,9 @@ public class CachingClusteredClientTest
     getDefaultQueryRunner().run(QueryPlus.wrap(queryLegacyTrue), responseContext);
 
     final Map<String, Integer> remainingResponseMap = (Map<String, Integer>) responseContext.get(ResponseContext.Keys.REMAINING_RESPONSES_FROM_QUERY_SERVERS);
-    Assert.assertEquals(1, remainingResponseMap.get(queryInclude.getId()).intValue());
-    Assert.assertEquals(0, remainingResponseMap.get(queryExclusive.getId()).intValue());
-    Assert.assertEquals(0, remainingResponseMap.get(queryLegacyTrue.getId()).intValue());
+    Assertions.assertEquals(1, remainingResponseMap.get(queryInclude.getId()).intValue());
+    Assertions.assertEquals(0, remainingResponseMap.get(queryExclusive.getId()).intValue());
+    Assertions.assertEquals(0, remainingResponseMap.get(queryLegacyTrue.getId()).intValue());
   }
 
   @Test
@@ -3218,8 +3221,8 @@ public class CachingClusteredClientTest
     getDefaultQueryRunner().run(QueryPlus.wrap(queryInclude), responseContext);
 
     final Map<String, Integer> remainingResponseMap = (Map<String, Integer>) responseContext.get(ResponseContext.Keys.REMAINING_RESPONSES_FROM_QUERY_SERVERS);
-    Assert.assertEquals(0, remainingResponseMap.get(queryExclude.getId()).intValue());
-    Assert.assertEquals(1, remainingResponseMap.get(queryInclude.getId()).intValue());
+    Assertions.assertEquals(0, remainingResponseMap.get(queryExclude.getId()).intValue());
+    Assertions.assertEquals(1, remainingResponseMap.get(queryInclude.getId()).intValue());
   }
 
   @SuppressWarnings("unchecked")
diff --git a/server/src/test/java/org/apache/druid/client/DirectDruidClientTest.java b/server/src/test/java/org/apache/druid/client/DirectDruidClientTest.java
index fa835b009fd..55379a74fea 100644
--- a/server/src/test/java/org/apache/druid/client/DirectDruidClientTest.java
+++ b/server/src/test/java/org/apache/druid/client/DirectDruidClientTest.java
@@ -57,15 +57,15 @@ import org.apache.druid.timeline.DataSegment;
 import org.apache.druid.timeline.SegmentId;
 import org.jboss.netty.handler.codec.http.HttpMethod;
 import org.jboss.netty.handler.timeout.ReadTimeoutException;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.ClassRule;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.junit.jupiter.api.io.TempDir;
 
 import java.io.ByteArrayInputStream;
+import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.PipedInputStream;
@@ -79,11 +79,11 @@ import java.util.concurrent.TimeUnit;
 
 public class DirectDruidClientTest
 {
-  @ClassRule
-  public static QueryStackTests.Junit4ConglomerateRule conglomerateRule = new QueryStackTests.Junit4ConglomerateRule();
+  @RegisterExtension
+  public static QueryStackTests.ConglomerateExtension conglomerateRule = new QueryStackTests.ConglomerateExtension();
 
-  @Rule
-  public TemporaryFolder temporaryFolder = new TemporaryFolder();
+  @TempDir
+  public File temporaryFolder;
 
   private final String hostName = "localhost:8080";
   private final ObjectMapper objectMapper = new DefaultObjectMapper();
@@ -92,7 +92,7 @@ public class DirectDruidClientTest
   private WrappingScheduledExecutorService queryCancellationExecutor;
   private BlockingExecutorService blockingExecutorService;
 
-  @Before
+  @BeforeEach
   public void setup()
   {
     responseContext.initialize();
@@ -104,7 +104,7 @@ public class DirectDruidClientTest
     );
   }
 
-  @After
+  @AfterEach
   public void teardown() throws InterruptedException
   {
     blockingExecutorService.shutdownNow();
@@ -134,22 +134,22 @@ public class DirectDruidClientTest
 
     Sequence s1 = client1.run(queryPlus, responseContext);
     List<Request> requests = queuedHttpClient.getRequests();
-    Assert.assertFalse(requests.isEmpty());
-    Assert.assertEquals(url, requests.get(0).getUrl());
-    Assert.assertEquals(HttpMethod.POST, requests.get(0).getMethod());
-    Assert.assertEquals(1, client1.getNumOpenConnections());
+    Assertions.assertFalse(requests.isEmpty());
+    Assertions.assertEquals(url, requests.get(0).getUrl());
+    Assertions.assertEquals(HttpMethod.POST, requests.get(0).getMethod());
+    Assertions.assertEquals(1, client1.getNumOpenConnections());
 
     // simulate read timeout on second request
     client1.run(queryPlus, responseContext);
-    Assert.assertEquals(2, client1.getNumOpenConnections());
+    Assertions.assertEquals(2, client1.getNumOpenConnections());
     futureException.setException(new ReadTimeoutException());
-    Assert.assertEquals(1, client1.getNumOpenConnections());
+    Assertions.assertEquals(1, client1.getNumOpenConnections());
 
     // subsequent connections should work (and remain open)
     client1.run(queryPlus, responseContext);
     client1.run(queryPlus, responseContext);
     client1.run(queryPlus, responseContext);
-    Assert.assertEquals(4, client1.getNumOpenConnections());
+    Assertions.assertEquals(4, client1.getNumOpenConnections());
 
     // produce result for first connection
     futureResult.set(
@@ -158,13 +158,13 @@ public class DirectDruidClientTest
         )
     );
     List<Result> results = s1.toList();
-    Assert.assertEquals(1, results.size());
-    Assert.assertEquals(DateTimes.of("2014-01-01T01:02:03Z"), results.get(0).getTimestamp());
-    Assert.assertEquals(3, client1.getNumOpenConnections());
+    Assertions.assertEquals(1, results.size());
+    Assertions.assertEquals(DateTimes.of("2014-01-01T01:02:03Z"), results.get(0).getTimestamp());
+    Assertions.assertEquals(3, client1.getNumOpenConnections());
 
     client2.run(queryPlus, responseContext);
     client2.run(queryPlus, responseContext);
-    Assert.assertEquals(2, client2.getNumOpenConnections());
+    Assertions.assertEquals(2, client2.getNumOpenConnections());
   }
 
   @Test
@@ -189,18 +189,18 @@ public class DirectDruidClientTest
     DirectDruidClient client = makeDirectDruidClient(testHttpClient);
     Sequence results = client.run(queryPlus, responseContext);
 
-    Assert.assertEquals(0, client.getNumOpenConnections());
+    Assertions.assertEquals(0, client.getNumOpenConnections());
     QueryInterruptedException actualException =
-        Assert.assertThrows(QueryInterruptedException.class, () -> results.toList());
-    Assert.assertEquals(hostName, actualException.getHost());
-    Assert.assertEquals("Query cancelled", actualException.getErrorCode());
-    Assert.assertEquals("Task was cancelled.", actualException.getCause().getMessage());
+        Assertions.assertThrows(QueryInterruptedException.class, () -> results.toList());
+    Assertions.assertEquals(hostName, actualException.getHost());
+    Assertions.assertEquals("Query cancelled", actualException.getErrorCode());
+    Assertions.assertEquals("Task was cancelled.", actualException.getCause().getMessage());
 
-    Assert.assertTrue(blockingExecutorService.hasPendingTasks());
+    Assertions.assertTrue(blockingExecutorService.hasPendingTasks());
     blockingExecutorService.finishNextPendingTask();
-    Assert.assertTrue(blockingExecutorService.hasPendingTasks());
-    ISE observedException = Assert.assertThrows(ISE.class, () -> blockingExecutorService.finishNextPendingTask());
-    Assert.assertTrue(observedException.getCause() instanceof CancellationException);
+    Assertions.assertTrue(blockingExecutorService.hasPendingTasks());
+    ISE observedException = Assertions.assertThrows(ISE.class, () -> blockingExecutorService.finishNextPendingTask());
+    Assertions.assertTrue(observedException.getCause() instanceof CancellationException);
 
   }
 
@@ -221,10 +221,10 @@ public class DirectDruidClientTest
     Sequence results = client.run(getQueryPlus(), responseContext);
 
     QueryInterruptedException actualException =
-        Assert.assertThrows(QueryInterruptedException.class, () -> results.toList());
-    Assert.assertEquals("testing1", actualException.getErrorCode());
-    Assert.assertEquals("testing2", actualException.getMessage());
-    Assert.assertEquals(hostName, actualException.getHost());
+        Assertions.assertThrows(QueryInterruptedException.class, () -> results.toList());
+    Assertions.assertEquals("testing1", actualException.getErrorCode());
+    Assertions.assertEquals("testing2", actualException.getMessage());
+    Assertions.assertEquals(hostName, actualException.getHost());
   }
 
   @Test
@@ -241,7 +241,7 @@ public class DirectDruidClientTest
     final PipedOutputStream out = new PipedOutputStream(in);
     timeoutFuture.set(in);
 
-    QueryTimeoutException actualException = Assert.assertThrows(
+    QueryTimeoutException actualException = Assertions.assertThrows(
         QueryTimeoutException.class,
         () -> {
           out.write(StringUtils.toUtf8("[{\"timestamp\":\"2014-01-01T01:02:03Z\"}"));
@@ -251,9 +251,9 @@ public class DirectDruidClientTest
           results.toList();
         }
     );
-    Assert.assertEquals("Query timeout", actualException.getErrorCode());
-    Assert.assertEquals(StringUtils.format("url[http://%s/druid/v2/] timed out", hostName), actualException.getMessage());
-    Assert.assertEquals(hostName, actualException.getHost());
+    Assertions.assertEquals("Query timeout", actualException.getErrorCode());
+    Assertions.assertEquals(StringUtils.format("url[http://%s/druid/v2/] timed out", hostName), actualException.getMessage());
+    Assertions.assertEquals(hostName, actualException.getHost());
   }
 
   @Test
@@ -264,10 +264,10 @@ public class DirectDruidClientTest
 
     QueryPlus query = getQueryPlus(Map.of(DirectDruidClient.QUERY_FAIL_TIME, System.currentTimeMillis() + 500));
     Sequence results = client.run(query, responseContext);
-    QueryTimeoutException actualException = Assert.assertThrows(QueryTimeoutException.class, results::toList);
-    Assert.assertEquals("Query timeout", actualException.getErrorCode());
-    Assert.assertEquals(StringUtils.format("Query [%s] timed out!", query.getQuery().getId()), actualException.getMessage());
-    Assert.assertEquals(hostName, actualException.getHost());
+    QueryTimeoutException actualException = Assertions.assertThrows(QueryTimeoutException.class, results::toList);
+    Assertions.assertEquals("Query timeout", actualException.getErrorCode());
+    Assertions.assertEquals(StringUtils.format("Query [%s] timed out!", query.getQuery().getId()), actualException.getMessage());
+    Assertions.assertEquals(hostName, actualException.getHost());
   }
 
   @Test
@@ -277,12 +277,12 @@ public class DirectDruidClientTest
     final DirectDruidClient client = makeDirectDruidClient(initHttpClientFromExistingClient(timeoutFuture));
 
     QueryPlus queryPlus = getQueryPlus(Map.of(DirectDruidClient.QUERY_FAIL_TIME, System.currentTimeMillis()));
-    QueryTimeoutException actualException = Assert.assertThrows(
+    QueryTimeoutException actualException = Assertions.assertThrows(
         QueryTimeoutException.class,
         () -> client.run(queryPlus, responseContext)
     );
-    Assert.assertEquals("Query timeout", actualException.getErrorCode());
-    Assert.assertEquals(
+    Assertions.assertEquals("Query timeout", actualException.getErrorCode());
+    Assertions.assertEquals(
         StringUtils.format(
             "Query[%s] url[http://%s/druid/v2/] timed out.",
             queryPlus.getQuery().getId(),
@@ -302,12 +302,12 @@ public class DirectDruidClientTest
         DirectDruidClient.QUERY_FAIL_TIME, System.currentTimeMillis() + 100
     ));
 
-    QueryTimeoutException actualException = Assert.assertThrows(
+    QueryTimeoutException actualException = Assertions.assertThrows(
         QueryTimeoutException.class,
         () -> client.run(queryPlus, responseContext)
     );
-    Assert.assertEquals("Query timeout", actualException.getErrorCode());
-    Assert.assertEquals(
+    Assertions.assertEquals("Query timeout", actualException.getErrorCode());
+    Assertions.assertEquals(
         StringUtils.format("Query[%s] url[http://%s/druid/v2/] timed out.",
                            queryPlus.getQuery().getId(),
                            hostName
@@ -320,8 +320,8 @@ public class DirectDruidClientTest
   {
     final DirectDruidClient client = makeDirectDruidClient(initHttpClientFromExistingClient());
 
-    Assert.assertThrows(RuntimeException.class, () -> client.run(getQueryPlus(), responseContext));
-    Assert.assertEquals(0, client.getNumOpenConnections());
+    Assertions.assertThrows(RuntimeException.class, () -> client.run(getQueryPlus(), responseContext));
+    Assertions.assertEquals(0, client.getNumOpenConnections());
   }
 
   @Test
@@ -332,8 +332,8 @@ public class DirectDruidClientTest
 
     client.run(getQueryPlus(), responseContext).toList();
 
-    Assert.assertEquals(1, stubEmitter.getMetricEventCount("query/node/time"));
-    Assert.assertEquals(1, stubEmitter.getMetricEventCount("query/node/bytes"));
+    Assertions.assertEquals(1, stubEmitter.getMetricEventCount("query/node/time"));
+    Assertions.assertEquals(1, stubEmitter.getMetricEventCount("query/node/bytes"));
   }
 
   @Test
@@ -348,10 +348,10 @@ public class DirectDruidClientTest
         DirectDruidClient.QUERY_FAIL_TIME, System.currentTimeMillis() + 50
     ));
 
-    Assert.assertThrows(QueryTimeoutException.class, () -> client.run(queryPlus, responseContext));
+    Assertions.assertThrows(QueryTimeoutException.class, () -> client.run(queryPlus, responseContext));
 
-    Assert.assertEquals(1, stubEmitter.getMetricEventCount("query/node/time"));
-    Assert.assertEquals(1, stubEmitter.getMetricEventCount("query/node/bytes"));
+    Assertions.assertEquals(1, stubEmitter.getMetricEventCount("query/node/time"));
+    Assertions.assertEquals(1, stubEmitter.getMetricEventCount("query/node/bytes"));
   }
 
   @Test
@@ -372,10 +372,10 @@ public class DirectDruidClientTest
     Sequence results = client.run(queryPlus, responseContext);
     Thread.sleep(600);
 
-    Assert.assertThrows(QueryTimeoutException.class, results::toList);
+    Assertions.assertThrows(QueryTimeoutException.class, results::toList);
 
-    Assert.assertEquals(1, stubEmitter.getMetricEventCount("query/node/time"));
-    Assert.assertEquals(1, stubEmitter.getMetricEventCount("query/node/bytes"));
+    Assertions.assertEquals(1, stubEmitter.getMetricEventCount("query/node/time"));
+    Assertions.assertEquals(1, stubEmitter.getMetricEventCount("query/node/bytes"));
   }
 
   @Test
@@ -388,12 +388,12 @@ public class DirectDruidClientTest
         DirectDruidClient.QUERY_FAIL_TIME, Long.MAX_VALUE
     ));
 
-    ResourceLimitExceededException actualException = Assert.assertThrows(
+    ResourceLimitExceededException actualException = Assertions.assertThrows(
         ResourceLimitExceededException.class,
         () -> client.run(queryPlus, responseContext)
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         StringUtils.format(
             "Query[%s] url[http://localhost:8080/druid/v2/] total bytes gathered[127] exceeds maxScatterGatherBytes[100]",
             queryPlus.getQuery().getId()
@@ -451,7 +451,7 @@ public class DirectDruidClientTest
   {
     try {
       return IndexBuilder.create()
-                         .tmpDir(temporaryFolder.newFolder())
+                         .tmpDir(newFolder(temporaryFolder, "junit"))
                          .segmentWriteOutMediumFactory(OffHeapMemorySegmentWriteOutMediumFactory.instance())
                          .schema(
                              new IncrementalIndexSchema.Builder()
@@ -465,7 +465,7 @@ public class DirectDruidClientTest
                              )
                          )
                          .inputFormat(TestIndex.DEFAULT_JSON_INPUT_FORMAT)
-                         .inputTmpDir(temporaryFolder.newFolder())
+                         .inputTmpDir(newFolder(temporaryFolder, "junit"))
                          .buildMMappedIndex();
     }
     catch (IOException e) {
@@ -482,4 +482,15 @@ public class DirectDruidClientTest
   {
     return QueryPlus.wrap(Druids.newTimeBoundaryQueryBuilder().dataSource("test").context(context).randomQueryId().build());
   }
+
+  private static File newFolder(File root, String... subDirs) throws IOException
+  {
+    if (subDirs.length == 0 || (subDirs.length == 1 && "junit".equals(subDirs[0]))) {
+      return org.apache.druid.java.util.common.FileUtils.createTempDirInLocation(root.toPath(), "junit");
+    }
+    String subFolder = String.join("/", subDirs);
+    File result = new File(root, subFolder);
+    org.apache.druid.java.util.common.FileUtils.mkdirp(result);
+    return result;
+  }
 }
diff --git a/server/src/test/java/org/apache/druid/segment/metadata/SegmentMetadataQuerySegmentWalkerTest.java b/server/src/test/java/org/apache/druid/segment/metadata/SegmentMetadataQuerySegmentWalkerTest.java
index e2cbff4cb86..68581b909ee 100644
--- a/server/src/test/java/org/apache/druid/segment/metadata/SegmentMetadataQuerySegmentWalkerTest.java
+++ b/server/src/test/java/org/apache/druid/segment/metadata/SegmentMetadataQuerySegmentWalkerTest.java
@@ -63,10 +63,10 @@ import org.apache.druid.timeline.partition.SingleDimensionShardSpec;
 import org.easymock.EasyMock;
 import org.easymock.IAnswer;
 import org.joda.time.Interval;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.ClassRule;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
 import org.mockito.Mockito;
 
 import java.io.IOException;
@@ -90,10 +90,10 @@ public class SegmentMetadataQuerySegmentWalkerTest
   private TestCoordinatorServerView testCoordinatorServerView;
   private Module module;
 
-  @ClassRule
-  public static QueryStackTests.Junit4ConglomerateRule conglomerateRule = new QueryStackTests.Junit4ConglomerateRule();
+  @RegisterExtension
+  public static QueryStackTests.ConglomerateExtension conglomerateRule = new QueryStackTests.ConglomerateExtension();
 
-  @Before
+  @BeforeEach
   public void setUp()
   {
     DruidHttpClientConfig httpClientConfig = new DruidHttpClientConfig()
@@ -172,7 +172,7 @@ public class SegmentMetadataQuerySegmentWalkerTest
                                                           .map(ServerExpectation::getSegment)
                                                           .map(segment -> segment.getId().toString())
                                                           .collect(Collectors.toSet());
-    Assert.assertEquals(expectedSegmentIds, actualSegmentIds);
+    Assertions.assertEquals(expectedSegmentIds, actualSegmentIds);
   }
 
   @Test
@@ -226,7 +226,7 @@ public class SegmentMetadataQuerySegmentWalkerTest
                                                           .map(ServerExpectation::getSegment)
                                                           .map(segment -> segment.getId().toString())
                                                           .collect(Collectors.toSet());
-    Assert.assertEquals(expectedSegmentIds, actualSegmentIds);
+    Assertions.assertEquals(expectedSegmentIds, actualSegmentIds);
   }
 
   @Test
@@ -294,7 +294,7 @@ public class SegmentMetadataQuerySegmentWalkerTest
                              .map(ServerExpectation::getSegment)
                              .map(segment -> segment.getId().toString())
                              .collect(Collectors.toSet());
-    Assert.assertEquals(expectedSegmentIds, actualSegmentIds);
+    Assertions.assertEquals(expectedSegmentIds, actualSegmentIds);
   }
 
   private Map<String, ServerExpectations> populateTimeline(
diff --git a/server/src/test/java/org/apache/druid/server/QueryStackTests.java b/server/src/test/java/org/apache/druid/server/QueryStackTests.java
index 2659f12def7..e64c554fcb3 100644
--- a/server/src/test/java/org/apache/druid/server/QueryStackTests.java
+++ b/server/src/test/java/org/apache/druid/server/QueryStackTests.java
@@ -104,10 +104,13 @@ import org.apache.druid.sql.calcite.util.CacheTestHelperModule.ResultCacheMode;
 import org.apache.druid.timeline.DataSegment;
 import org.apache.druid.timeline.VersionedIntervalTimeline;
 import org.apache.druid.utils.JvmUtils;
-import org.junit.Assert;
-import org.junit.rules.ExternalResource;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.extension.AfterAllCallback;
+import org.junit.jupiter.api.extension.BeforeAllCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
 
 import javax.annotation.Nullable;
+
 import java.io.IOException;
 import java.util.Collections;
 import java.util.Map;
@@ -118,20 +121,20 @@ import java.util.Set;
  */
 public class QueryStackTests
 {
-  public static class Junit4ConglomerateRule extends ExternalResource
+  public static class ConglomerateExtension implements BeforeAllCallback, AfterAllCallback
   {
     private Closer closer;
     private QueryRunnerFactoryConglomerate conglomerate;
 
     @Override
-    protected void before()
+    public void beforeAll(ExtensionContext context)
     {
       closer = Closer.create();
       conglomerate = QueryStackTests.createQueryRunnerFactoryConglomerate(closer);
     }
 
     @Override
-    protected void after()
+    public void afterAll(ExtensionContext context)
     {
       try {
         closer.close();
@@ -312,7 +315,7 @@ public class QueryStackTests
     final TestBufferPool testBufferPool = TestBufferPool.offHeap(COMPUTE_BUFFER_SIZE, Integer.MAX_VALUE);
     closer.register(() -> {
       // Verify that all objects have been returned to the pool.
-      Assert.assertEquals(0, testBufferPool.getOutstandingObjectCount());
+      Assertions.assertEquals(0, testBufferPool.getOutstandingObjectCount());
     });
     return testBufferPool;
   }
diff --git a/sql/src/test/java/org/apache/druid/quidem/DruidAvaticaDriverTest.java b/sql/src/test/java/org/apache/druid/quidem/DruidAvaticaDriverTest.java
index 3f039814c0f..2593f3d579e 100644
--- a/sql/src/test/java/org/apache/druid/quidem/DruidAvaticaDriverTest.java
+++ b/sql/src/test/java/org/apache/druid/quidem/DruidAvaticaDriverTest.java
@@ -28,9 +28,9 @@ import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Statement;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class DruidAvaticaDriverTest
 {
diff --git a/sql/src/test/java/org/apache/druid/quidem/DruidQuidemCommandHandler.java b/sql/src/test/java/org/apache/druid/quidem/DruidQuidemCommandHandler.java
index af52f4feb57..ad09ff1fb4f 100644
--- a/sql/src/test/java/org/apache/druid/quidem/DruidQuidemCommandHandler.java
+++ b/sql/src/test/java/org/apache/druid/quidem/DruidQuidemCommandHandler.java
@@ -52,7 +52,7 @@ import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import static org.junit.Assume.assumeFalse;
+import static org.junit.jupiter.api.Assumptions.assumeFalse;
 
 public class DruidQuidemCommandHandler implements CommandHandler
 {
@@ -357,7 +357,7 @@ public class DruidQuidemCommandHandler implements CommandHandler
         try {
           Injector injector = DruidConnectionExtras.unwrapOrThrow(context.connection()).getInjector();
           SqlTestFrameworkConfig cfg = injector.getInstance(SqlTestFrameworkConfig.class);
-          assumeFalse(message, cfg.componentSupplier.getSimpleName().equals(supplierName));
+          assumeFalse(cfg.componentSupplier.getSimpleName().equals(supplierName), message);
         }
         catch (Exception e) {
           // This is packaged as an Error because Quidem grabs anything else and pushes it into the output file
diff --git a/sql/src/test/java/org/apache/druid/quidem/DruidQuidemTestBase.java b/sql/src/test/java/org/apache/druid/quidem/DruidQuidemTestBase.java
index 4f5e03885aa..7da83f33180 100644
--- a/sql/src/test/java/org/apache/druid/quidem/DruidQuidemTestBase.java
+++ b/sql/src/test/java/org/apache/druid/quidem/DruidQuidemTestBase.java
@@ -40,11 +40,11 @@ import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.sql.calcite.MultiComponentSupplier;
 import org.apache.druid.sql.calcite.SqlTestFrameworkConfig;
 import org.apache.druid.sql.calcite.util.SqlTestFramework.QueryComponentSupplier;
-import org.junit.AssumptionViolatedException;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.TestInstance;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
+import org.opentest4j.TestAbortedException;
 
 import java.io.File;
 import java.io.FileNotFoundException;
@@ -323,10 +323,10 @@ public abstract class DruidQuidemTestBase
       druidQuidemRunner.run(inFile, outFile, testConfig.componentSupplierName);
     }
     catch (Error e) {
-      // This catch is needed to workaround the way Quidem currently handles AssumptionViolatedException
+      // This catch is needed to workaround the way Quidem currently handles TestAbortedException
       Throwable cause = e.getCause();
-      if (cause != null && cause instanceof AssumptionViolatedException) {
-        AssumptionViolatedException assumptionViolatedException = (AssumptionViolatedException) cause;
+      if (cause != null && cause instanceof TestAbortedException) {
+        TestAbortedException assumptionViolatedException = (TestAbortedException) cause;
         throw assumptionViolatedException;
       }
       throw e;
diff --git a/sql/src/test/java/org/apache/druid/sql/SqlLifecycleManagerTest.java b/sql/src/test/java/org/apache/druid/sql/SqlLifecycleManagerTest.java
index 74d5439fcec..59b8c77860f 100644
--- a/sql/src/test/java/org/apache/druid/sql/SqlLifecycleManagerTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/SqlLifecycleManagerTest.java
@@ -22,9 +22,9 @@ package org.apache.druid.sql;
 import com.google.common.collect.ImmutableList;
 import org.apache.druid.server.security.ResourceAction;
 import org.apache.druid.sql.SqlLifecycleManager.Cancelable;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import java.util.Collections;
 import java.util.List;
@@ -34,7 +34,7 @@ public class SqlLifecycleManagerTest
 {
   private SqlLifecycleManager lifecycleManager;
 
-  @Before
+  @BeforeEach
   public void setup()
   {
     lifecycleManager = new SqlLifecycleManager();
@@ -46,7 +46,7 @@ public class SqlLifecycleManagerTest
     final String sqlId = "sqlId";
     Cancelable lifecycle = mockLifecycle();
     lifecycleManager.add(sqlId, lifecycle);
-    Assert.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId));
+    Assertions.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId));
   }
 
   @Test
@@ -55,9 +55,9 @@ public class SqlLifecycleManagerTest
     final String sqlId = "sqlId";
     Cancelable lifecycle = mockLifecycle();
     lifecycleManager.add(sqlId, lifecycle);
-    Assert.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId));
+    Assertions.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId));
     lifecycleManager.remove(sqlId, lifecycle);
-    Assert.assertEquals(ImmutableList.of(), lifecycleManager.getAll(sqlId));
+    Assertions.assertEquals(ImmutableList.of(), lifecycleManager.getAll(sqlId));
   }
 
   @Test
@@ -66,9 +66,9 @@ public class SqlLifecycleManagerTest
     final String sqlId = "sqlId";
     Cancelable lifecycle = mockLifecycle();
     lifecycleManager.add(sqlId, lifecycle);
-    Assert.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId));
+    Assertions.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId));
     lifecycleManager.remove("invalid", lifecycle);
-    Assert.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId));
+    Assertions.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId));
   }
 
   @Test
@@ -77,9 +77,9 @@ public class SqlLifecycleManagerTest
     final String sqlId = "sqlId";
     Cancelable lifecycle = mockLifecycle();
     lifecycleManager.add(sqlId, lifecycle);
-    Assert.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId));
+    Assertions.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId));
     lifecycleManager.remove(sqlId, mockLifecycle());
-    Assert.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId));
+    Assertions.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId));
   }
 
   @Test
@@ -92,9 +92,9 @@ public class SqlLifecycleManagerTest
         mockLifecycle()
     );
     lifecycles.forEach(lifecycle -> lifecycleManager.add(sqlId, lifecycle));
-    Assert.assertEquals(lifecycles, lifecycleManager.getAll(sqlId));
+    Assertions.assertEquals(lifecycles, lifecycleManager.getAll(sqlId));
     lifecycleManager.removeAll(sqlId, ImmutableList.of(lifecycles.get(0), lifecycles.get(1)));
-    Assert.assertEquals(ImmutableList.of(lifecycles.get(2)), lifecycleManager.getAll(sqlId));
+    Assertions.assertEquals(ImmutableList.of(lifecycles.get(2)), lifecycleManager.getAll(sqlId));
   }
 
   @Test
@@ -107,9 +107,9 @@ public class SqlLifecycleManagerTest
         mockLifecycle()
     );
     lifecycles.forEach(lifecycle -> lifecycleManager.add(sqlId, lifecycle));
-    Assert.assertEquals(lifecycles, lifecycleManager.getAll(sqlId));
+    Assertions.assertEquals(lifecycles, lifecycleManager.getAll(sqlId));
     lifecycleManager.removeAll("invalid", ImmutableList.of(lifecycles.get(0), lifecycles.get(1)));
-    Assert.assertEquals(lifecycles, lifecycleManager.getAll(sqlId));
+    Assertions.assertEquals(lifecycles, lifecycleManager.getAll(sqlId));
   }
 
   @Test
@@ -124,8 +124,8 @@ public class SqlLifecycleManagerTest
     lifecycles.forEach(lifecycle -> lifecycleManager.add(sqlId, lifecycle));
     final List<Cancelable> lifecyclesFromGetAll = lifecycleManager.getAll(sqlId);
     lifecycleManager.removeAll(sqlId, lifecyclesFromGetAll);
-    Assert.assertEquals(lifecycles, lifecyclesFromGetAll);
-    Assert.assertTrue(lifecycleManager.getAll(sqlId).isEmpty());
+    Assertions.assertEquals(lifecycles, lifecyclesFromGetAll);
+    Assertions.assertTrue(lifecycleManager.getAll(sqlId).isEmpty());
   }
 
   private static Cancelable mockLifecycle()
diff --git a/sql/src/test/java/org/apache/druid/sql/SqlQueryPlusTest.java b/sql/src/test/java/org/apache/druid/sql/SqlQueryPlusTest.java
index 1c793b9ef55..252460f65fe 100644
--- a/sql/src/test/java/org/apache/druid/sql/SqlQueryPlusTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/SqlQueryPlusTest.java
@@ -23,8 +23,8 @@ import org.apache.druid.error.DruidException;
 import org.apache.druid.error.DruidExceptionMatcher;
 import org.apache.druid.sql.calcite.util.CalciteTests;
 import org.hamcrest.MatcherAssert;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 import java.util.Map;
 
@@ -34,7 +34,7 @@ public class SqlQueryPlusTest
   public void testSyntaxError()
   {
     // SqlQueryPlus throws parse errors on build() if the statement is invalid
-    final DruidException e = Assert.assertThrows(
+    final DruidException e = Assertions.assertThrows(
         DruidException.class,
         () -> SqlQueryPlus.builder("SELECT COUNT(*) AS cnt, 'foo' AS")
                           .auth(CalciteTests.REGULAR_USER_AUTH_RESULT)
@@ -59,7 +59,7 @@ public class SqlQueryPlusTest
                     .buildJdbc();
 
     // It does throw exceptions on freshCopy(), though.
-    final DruidException e = Assert.assertThrows(
+    final DruidException e = Assertions.assertThrows(
         DruidException.class,
         sqlQueryPlus::freshCopy
     );
@@ -83,24 +83,24 @@ public class SqlQueryPlusTest
                     .queryContext(userProvidedContext)
                     .auth(CalciteTests.REGULAR_USER_AUTH_RESULT);
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         Map.of("key", "user-provided-value", "key2", "system-default2"),
         sqlQueryPlusBuilder.build().context()
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         Map.of("key", "user-provided-value", "key2", "system-default2"),
         sqlQueryPlusBuilder.buildJdbc().context()
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         Map.of("key", "user-provided-value", "key2", "system-default2"),
         sqlQueryPlusBuilder.build().withContext(systemDefaultContext, userProvidedContext).context()
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         Map.of("key", "system-default", "key2", "system-default2"),
         sqlQueryPlusBuilder.build().withContext(systemDefaultContext, Map.of()).context()
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         Map.of("key", "user-provided-value"),
         sqlQueryPlusBuilder.build().withContext(Map.of(), userProvidedContext).context()
     );
diff --git a/sql/src/test/java/org/apache/druid/sql/SqlRowTransformerTest.java b/sql/src/test/java/org/apache/druid/sql/SqlRowTransformerTest.java
index 5286df34d6b..bb024463665 100644
--- a/sql/src/test/java/org/apache/druid/sql/SqlRowTransformerTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/SqlRowTransformerTest.java
@@ -32,7 +32,7 @@ import org.apache.druid.sql.calcite.util.CalciteTestBase;
 import org.joda.time.DateTime;
 import org.joda.time.DateTimeZone;
 import org.joda.time.format.ISODateTimeFormat;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
@@ -84,7 +84,7 @@ public class SqlRowTransformerTest extends CalciteTestBase
         expectedRow[2],
         null
     };
-    Assert.assertArrayEquals(
+    Assertions.assertArrayEquals(
         expectedRow,
         IntStream.range(0, expectedRow.length).mapToObj(i -> transformer.transform(row, i)).toArray()
     );
@@ -112,7 +112,7 @@ public class SqlRowTransformerTest extends CalciteTestBase
         expectedRow[2],
         null
     };
-    Assert.assertArrayEquals(
+    Assertions.assertArrayEquals(
         expectedRow,
         IntStream.range(0, expectedRow.length).mapToObj(i -> transformer.transform(row, i)).toArray()
     );
@@ -126,7 +126,7 @@ public class SqlRowTransformerTest extends CalciteTestBase
         rowType
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         rowType.getFieldList().stream().map(RelDataTypeField::getName).collect(Collectors.toList()),
         transformer.getFieldList()
     );
diff --git a/sql/src/test/java/org/apache/druid/sql/SqlStatementTest.java b/sql/src/test/java/org/apache/druid/sql/SqlStatementTest.java
index 8856a19331f..d17b72f6d98 100644
--- a/sql/src/test/java/org/apache/druid/sql/SqlStatementTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/SqlStatementTest.java
@@ -65,16 +65,17 @@ import org.apache.druid.sql.calcite.util.CalciteTests;
 import org.apache.druid.sql.hook.DruidHookDispatcher;
 import org.easymock.EasyMock;
 import org.hamcrest.MatcherAssert;
-import org.junit.After;
-import org.junit.AfterClass;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.ClassRule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
 
 import javax.servlet.http.HttpServletRequest;
+
+import java.io.File;
 import java.io.IOException;
 import java.util.Collections;
 import java.util.List;
@@ -82,19 +83,19 @@ import java.util.Map;
 import java.util.concurrent.TimeUnit;
 
 import static org.apache.druid.sql.calcite.BaseCalciteQueryTest.assertResultsEquals;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
 
 public class SqlStatementTest
 {
   private static QueryRunnerFactoryConglomerate conglomerate;
   private static SpecificSegmentsQuerySegmentWalker walker;
   private static Closer resourceCloser;
-  @ClassRule
-  public static TemporaryFolder temporaryFolder = new TemporaryFolder();
+  @TempDir
+  public static File temporaryFolder;
   private ListeningExecutorService executorService;
   private final DefaultQueryConfig defaultQueryConfig = new DefaultQueryConfig(
       ImmutableMap.of("DEFAULT_KEY", "DEFAULT_VALUE"));
@@ -102,8 +103,8 @@ public class SqlStatementTest
   private PolicyEnforcer policyEnforcer;
   private SqlStatementFactory sqlStatementFactory;
 
-  @BeforeClass
-  public static void setUpClass() throws Exception
+  @BeforeAll
+  public static void setUpClass()
   {
     resourceCloser = Closer.create();
     conglomerate = QueryStackTests.createQueryRunnerFactoryConglomerate(resourceCloser);
@@ -125,17 +126,17 @@ public class SqlStatementTest
       }
     };
 
-    walker = CalciteTests.createMockWalker(conglomerate, temporaryFolder.newFolder(), scheduler);
+    walker = CalciteTests.createMockWalker(conglomerate, temporaryFolder, scheduler);
     resourceCloser.register(walker);
   }
 
-  @AfterClass
+  @AfterAll
   public static void tearDownClass() throws IOException
   {
     resourceCloser.close();
   }
 
-  @Before
+  @BeforeEach
   public void setUp()
   {
     executorService = MoreExecutors.listeningDecorator(Execs.multiThreaded(8, "test_sql_resource_%s"));
@@ -144,7 +145,7 @@ public class SqlStatementTest
     this.sqlStatementFactory = buildSqlStatementFactory();
   }
 
-  @After
+  @AfterEach
   public void tearDown() throws Exception
   {
     executorService.shutdownNow();
@@ -254,11 +255,11 @@ public class SqlStatementTest
     );
     DirectStatement stmt = sqlStatementFactory.directStatement(sqlReq);
     ResultSet resultSet = stmt.plan();
-    DruidException e = Assert.assertThrows(DruidException.class, () -> resultSet.run());
+    DruidException e = Assertions.assertThrows(DruidException.class, () -> resultSet.run());
 
-    Assert.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
-    Assert.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona());
-    Assert.assertEquals("Failed security validation with dataSource [foo]", e.getMessage());
+    Assertions.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
+    Assertions.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona());
+    Assertions.assertEquals("Failed security validation with dataSource [foo]", e.getMessage());
   }
 
   @Test
@@ -390,11 +391,11 @@ public class SqlStatementTest
         request(true)
     );
     ResultSet resultSet = stmt.plan();
-    DruidException e = Assert.assertThrows(DruidException.class, () -> resultSet.run());
+    DruidException e = Assertions.assertThrows(DruidException.class, () -> resultSet.run());
 
-    Assert.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
-    Assert.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona());
-    Assert.assertEquals("Failed security validation with dataSource [foo]", e.getMessage());
+    Assertions.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
+    Assertions.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona());
+    Assertions.assertEquals("Failed security validation with dataSource [foo]", e.getMessage());
   }
 
   @Test
@@ -495,11 +496,11 @@ public class SqlStatementTest
         CalciteTests.REGULAR_USER_AUTH_RESULT
     );
     PreparedStatement stmt = sqlStatementFactory.preparedStatement(sqlReq);
-    DruidException e = Assert.assertThrows(DruidException.class, () -> stmt.execute(Collections.emptyList(), null).execute());
+    DruidException e = Assertions.assertThrows(DruidException.class, () -> stmt.execute(Collections.emptyList(), null).execute());
 
-    Assert.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
-    Assert.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona());
-    Assert.assertEquals("Failed security validation with dataSource [foo]", e.getMessage());
+    Assertions.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
+    Assertions.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona());
+    Assertions.assertEquals("Failed security validation with dataSource [foo]", e.getMessage());
   }
 
   @Test
@@ -532,7 +533,7 @@ public class SqlStatementTest
     DirectStatement stmt = sqlStatementFactory.directStatement(sqlReq);
     Map<String, Object> context = stmt.context();
     // should contain only query id, not bySegment since it is not valid for SQL
-    Assert.assertEquals(Collections.singleton(QueryContexts.CTX_SQL_QUERY_ID), context.keySet());
+    Assertions.assertEquals(Collections.singleton(QueryContexts.CTX_SQL_QUERY_ID), context.keySet());
   }
 
   private SqlStatementFactory buildSqlStatementFactory()
diff --git a/sql/src/test/java/org/apache/druid/sql/avatica/AvaticaModuleTest.java b/sql/src/test/java/org/apache/druid/sql/avatica/AvaticaModuleTest.java
index 1918736af32..ec1554c3f25 100644
--- a/sql/src/test/java/org/apache/druid/sql/avatica/AvaticaModuleTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/avatica/AvaticaModuleTest.java
@@ -32,22 +32,21 @@ import org.apache.druid.jackson.JacksonModule;
 import org.apache.druid.java.util.metrics.Monitor;
 import org.apache.druid.server.DruidNode;
 import org.easymock.EasyMock;
-import org.easymock.EasyMockRunner;
+import org.easymock.EasyMockExtension;
 import org.easymock.Mock;
 import org.eclipse.jetty.server.Handler;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 
 import javax.validation.Validation;
 import javax.validation.Validator;
+
 import java.util.Properties;
 import java.util.Set;
 
-@RunWith(EasyMockRunner.class)
+@ExtendWith(EasyMockExtension.class)
 public class AvaticaModuleTest
 {
   private static final String HOST_AND_PORT = "HOST_AND_PORT";
@@ -57,13 +56,10 @@ public class AvaticaModuleTest
   @Mock
   private DruidMeta druidMeta;
 
-  @Rule
-  public ExpectedException expectedException = ExpectedException.none();
-
   private AvaticaModule target;
   private Injector injector;
 
-  @Before
+  @BeforeEach
   public void setUp()
   {
     EasyMock.expect(druidNode.getHostAndPortToUse()).andStubReturn(HOST_AND_PORT);
@@ -85,9 +81,9 @@ public class AvaticaModuleTest
   public void testAvaticaMonitorIsInjectedAsSingleton()
   {
     AvaticaMonitor monitor = injector.getInstance(AvaticaMonitor.class);
-    Assert.assertNotNull(monitor);
+    Assertions.assertNotNull(monitor);
     AvaticaMonitor other = injector.getInstance(AvaticaMonitor.class);
-    Assert.assertSame(monitor, other);
+    Assertions.assertSame(monitor, other);
   }
 
   @Test
@@ -95,22 +91,22 @@ public class AvaticaModuleTest
   {
     Set<Class<? extends Monitor>> monitors =
         injector.getInstance(Key.get(new TypeLiteral<>() {}));
-    Assert.assertTrue(monitors.contains(AvaticaMonitor.class));
+    Assertions.assertTrue(monitors.contains(AvaticaMonitor.class));
   }
 
   @Test
   public void testAvaticaServerConfigIsInjectable()
   {
     AvaticaServerConfig config = injector.getInstance(AvaticaServerConfig.class);
-    Assert.assertNotNull(config);
-    Assert.assertEquals(AvaticaServerConfig.DEFAULT_MAX_CONNECTIONS, config.getMaxConnections());
-    Assert.assertEquals(
+    Assertions.assertNotNull(config);
+    Assertions.assertEquals(AvaticaServerConfig.DEFAULT_MAX_CONNECTIONS, config.getMaxConnections());
+    Assertions.assertEquals(
         AvaticaServerConfig.DEFAULT_MAX_STATEMENTS_PER_CONNECTION,
         config.getMaxStatementsPerConnection()
     );
-    Assert.assertEquals(AvaticaServerConfig.DEFAULT_CONNECTION_IDLE_TIMEOUT, config.getConnectionIdleTimeout());
-    Assert.assertEquals(AvaticaServerConfig.DEFAULT_MIN_ROWS_PER_FRAME, config.getMinRowsPerFrame());
-    Assert.assertEquals(AvaticaServerConfig.DEFAULT_MAX_ROWS_PER_FRAME, config.getMaxRowsPerFrame());
+    Assertions.assertEquals(AvaticaServerConfig.DEFAULT_CONNECTION_IDLE_TIMEOUT, config.getConnectionIdleTimeout());
+    Assertions.assertEquals(AvaticaServerConfig.DEFAULT_MIN_ROWS_PER_FRAME, config.getMinRowsPerFrame());
+    Assertions.assertEquals(AvaticaServerConfig.DEFAULT_MAX_ROWS_PER_FRAME, config.getMaxRowsPerFrame());
   }
 
   @Test
@@ -125,15 +121,15 @@ public class AvaticaModuleTest
     properties.setProperty("druid.sql.avatica.minRowsPerFrame", "10000");
     provider.inject(properties, injector.getInstance(JsonConfigurator.class));
     final AvaticaServerConfig config = provider.get();
-    Assert.assertNotNull(config);
-    Assert.assertEquals(AvaticaServerConfig.DEFAULT_MAX_CONNECTIONS, config.getMaxConnections());
-    Assert.assertEquals(
+    Assertions.assertNotNull(config);
+    Assertions.assertEquals(AvaticaServerConfig.DEFAULT_MAX_CONNECTIONS, config.getMaxConnections());
+    Assertions.assertEquals(
         AvaticaServerConfig.DEFAULT_MAX_STATEMENTS_PER_CONNECTION,
         config.getMaxStatementsPerConnection()
     );
-    Assert.assertEquals(AvaticaServerConfig.DEFAULT_CONNECTION_IDLE_TIMEOUT, config.getConnectionIdleTimeout());
-    Assert.assertEquals(10_000, config.getMinRowsPerFrame());
-    Assert.assertEquals(50_000, config.getMaxRowsPerFrame());
+    Assertions.assertEquals(AvaticaServerConfig.DEFAULT_CONNECTION_IDLE_TIMEOUT, config.getConnectionIdleTimeout());
+    Assertions.assertEquals(10_000, config.getMinRowsPerFrame());
+    Assertions.assertEquals(50_000, config.getMaxRowsPerFrame());
   }
 
   @Test
@@ -147,22 +143,20 @@ public class AvaticaModuleTest
     properties.setProperty("druid.sql.avatica.maxRowsPerFrame", "50");
     provider.inject(properties, injector.getInstance(JsonConfigurator.class));
     final AvaticaServerConfig config = provider.get();
-    Assert.assertNotNull(config);
-    Assert.assertEquals(AvaticaServerConfig.DEFAULT_MAX_CONNECTIONS, config.getMaxConnections());
-    Assert.assertEquals(
+    Assertions.assertNotNull(config);
+    Assertions.assertEquals(AvaticaServerConfig.DEFAULT_MAX_CONNECTIONS, config.getMaxConnections());
+    Assertions.assertEquals(
         AvaticaServerConfig.DEFAULT_MAX_STATEMENTS_PER_CONNECTION,
         config.getMaxStatementsPerConnection()
     );
-    Assert.assertEquals(AvaticaServerConfig.DEFAULT_CONNECTION_IDLE_TIMEOUT, config.getConnectionIdleTimeout());
-    Assert.assertEquals(50, config.getMinRowsPerFrame());
-    Assert.assertEquals(50, config.getMaxRowsPerFrame());
+    Assertions.assertEquals(AvaticaServerConfig.DEFAULT_CONNECTION_IDLE_TIMEOUT, config.getConnectionIdleTimeout());
+    Assertions.assertEquals(50, config.getMinRowsPerFrame());
+    Assertions.assertEquals(50, config.getMaxRowsPerFrame());
   }
 
   @Test
   public void testAvaticaServerConfigPropertiesBadMinRowsPerFrame()
   {
-    expectedException.expect(IllegalArgumentException.class);
-    expectedException.expectMessage("'druid.sql.avatica.minRowsPerFrame' must be set to a value greater than 0");
     Properties properties = new Properties();
     final JsonConfigProvider<AvaticaServerConfig> provider = JsonConfigProvider.of(
         "druid.sql.avatica",
@@ -171,26 +165,32 @@ public class AvaticaModuleTest
     properties.setProperty("druid.sql.avatica.minRowsPerFrame", "-1");
     provider.inject(properties, injector.getInstance(JsonConfigurator.class));
     final AvaticaServerConfig config = provider.get();
-    Assert.assertNotNull(config);
-    config.getMinRowsPerFrame();
+    Assertions.assertNotNull(config);
+    final IllegalArgumentException e = Assertions.assertThrows(
+        IllegalArgumentException.class,
+        config::getMinRowsPerFrame
+    );
+    Assertions.assertTrue(
+        e.getMessage().contains("'druid.sql.avatica.minRowsPerFrame' must be set to a value greater than 0")
+    );
   }
 
   @Test
   public void testDruidAvaticaJsonHandlerIsInjected()
   {
     DruidAvaticaJsonHandler handler = injector.getInstance(DruidAvaticaJsonHandler.class);
-    Assert.assertNotNull(handler);
+    Assertions.assertNotNull(handler);
     DruidAvaticaJsonHandler other = injector.getInstance(DruidAvaticaJsonHandler.class);
-    Assert.assertNotSame(handler, other);
+    Assertions.assertNotSame(handler, other);
   }
 
   @Test
   public void testDruidAvaticaProtobufHandlerIsInjected()
   {
     DruidAvaticaProtobufHandler handler = injector.getInstance(DruidAvaticaProtobufHandler.class);
-    Assert.assertNotNull(handler);
+    Assertions.assertNotNull(handler);
     DruidAvaticaProtobufHandler other = injector.getInstance(DruidAvaticaProtobufHandler.class);
-    Assert.assertNotSame(handler, other);
+    Assertions.assertNotSame(handler, other);
   }
 
   @Test
@@ -198,13 +198,13 @@ public class AvaticaModuleTest
   {
     Set<Handler> handlers =
         injector.getInstance(Key.get(new TypeLiteral<>() {}));
-    Assert.assertTrue(handlers.stream().anyMatch(h -> DruidAvaticaJsonHandler.class.equals(h.getClass())));
+    Assertions.assertTrue(handlers.stream().anyMatch(h -> DruidAvaticaJsonHandler.class.equals(h.getClass())));
   }
 
   @Test
   public void testDruidAvaticaProtobufHandlerIsRegisterdWithJerseyModule()
   {
     Set<Handler> handlers = injector.getInstance(Key.get(new TypeLiteral<>() {}));
-    Assert.assertTrue(handlers.stream().anyMatch(h -> DruidAvaticaProtobufHandler.class.equals(h.getClass())));
+    Assertions.assertTrue(handlers.stream().anyMatch(h -> DruidAvaticaProtobufHandler.class.equals(h.getClass())));
   }
 }
diff --git a/sql/src/test/java/org/apache/druid/sql/avatica/DruidAvaticaHandlerTest.java b/sql/src/test/java/org/apache/druid/sql/avatica/DruidAvaticaHandlerTest.java
index 416f04624c1..1c0a68aa86a 100644
--- a/sql/src/test/java/org/apache/druid/sql/avatica/DruidAvaticaHandlerTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/avatica/DruidAvaticaHandlerTest.java
@@ -99,9 +99,9 @@ import org.apache.druid.sql.hook.DruidHookDispatcher;
 import org.eclipse.jetty.server.Server;
 import org.joda.time.DateTime;
 import org.joda.time.DateTimeZone;
-import org.junit.Assert;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -361,7 +361,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
     try (Statement stmt = client.createStatement()) {
       final ResultSet resultSet = stmt.executeQuery("SELECT COUNT(*) AS cnt FROM druid.foo;");
       final List<Map<String, Object>> rows = getRows(resultSet);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           ImmutableList.of(
               ImmutableMap.of("cnt", 6L)
           ),
@@ -377,10 +377,10 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
     propertiesSetForbiddenKey.setProperty("user", "regularUserLA");
     propertiesSetForbiddenKey.setProperty("forbidden-key", "val");
     try (Statement stmt = DriverManager.getConnection(server.url, propertiesSetForbiddenKey).createStatement()) {
-      AvaticaSqlException e = Assert.assertThrows(AvaticaSqlException.class, () -> {
+      AvaticaSqlException e = Assertions.assertThrows(AvaticaSqlException.class, () -> {
         stmt.executeQuery("SELECT COUNT(*) AS cnt FROM druid.foo");
       });
-      Assert.assertTrue(e.getMessage().contains("Remote driver error: Unauthorized"));
+      Assertions.assertTrue(e.getMessage().contains("Remote driver error: Unauthorized"));
     }
   }
 
@@ -390,7 +390,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
     try (Statement stmt = clientNoTrailingSlash.createStatement()) {
       final ResultSet resultSet = stmt.executeQuery("SELECT COUNT(*) AS cnt FROM druid.foo");
       final List<Map<String, Object>> rows = getRows(resultSet);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           ImmutableList.of(
               ImmutableMap.of("cnt", 6L)
           ),
@@ -405,7 +405,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
     try (PreparedStatement stmt = client.prepareStatement("SELECT COUNT(*) AS cnt FROM druid.foo")) {
       final ResultSet resultSet = stmt.executeQuery();
       final List<Map<String, Object>> rows = getRows(resultSet);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           ImmutableList.of(
               ImmutableMap.of("cnt", 6L)
           ),
@@ -422,7 +422,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
           "SELECT __time, CAST(__time AS DATE) AS t2 FROM druid.foo LIMIT 1"
       );
 
-      Assert.assertEquals(
+      Assertions.assertEquals(
           ImmutableList.of(
               ImmutableMap.of(
                   "__time", new Timestamp(DateTimes.of("2000-01-01T00:00:00.000Z").getMillis()),
@@ -447,7 +447,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
 
       final List<Map<String, Object>> resultRows = getRows(resultSet);
 
-      Assert.assertEquals(
+      Assertions.assertEquals(
           ImmutableList.of(
               ImmutableMap.of(
                   "__time", new Timestamp(Calcites.jodaToCalciteTimestamp(localDateTime, timeZone)),
@@ -467,7 +467,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
           "SELECT dim2 AS \"x\", dim2 AS \"y\" FROM druid.foo LIMIT 1"
       );
 
-      Assert.assertEquals(
+      Assertions.assertEquals(
           ImmutableList.of(
               ImmutableMap.of("x", "a", "y", "a")
           ),
@@ -484,7 +484,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
           "SELECT dim2, dim2 IS NULL AS isnull FROM druid.foo LIMIT 1"
       );
 
-      Assert.assertEquals(
+      Assertions.assertEquals(
           ImmutableList.of(
               ImmutableMap.of("dim2", "a", "isnull", false)
           ),
@@ -501,7 +501,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
           "EXPLAIN PLAN FOR SELECT COUNT(*) AS cnt FROM druid.foo"
       );
 
-      Assert.assertEquals(
+      Assertions.assertEquals(
           ImmutableList.of(
               ImmutableMap.of(
                   "PLAN",
@@ -524,7 +524,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
   public void testDatabaseMetaDataCatalogs() throws SQLException
   {
     final DatabaseMetaData metaData = client.getMetaData();
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             row(Pair.of("TABLE_CAT", "druid"))
         ),
@@ -536,7 +536,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
   public void testDatabaseMetaDataSchemas() throws SQLException
   {
     final DatabaseMetaData metaData = client.getMetaData();
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             row(Pair.of("TABLE_CATALOG", "druid"), Pair.of("TABLE_SCHEM", "druid"))
         ),
@@ -548,7 +548,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
   public void testDatabaseMetaDataTables() throws SQLException
   {
     final DatabaseMetaData metaData = client.getMetaData();
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             row(
                 Pair.of("TABLE_CAT", "druid"),
@@ -653,7 +653,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
   public void testDatabaseMetaDataTablesAsSuperuser() throws SQLException
   {
     final DatabaseMetaData metaData = superuserClient.getMetaData();
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             row(
                 Pair.of("TABLE_CAT", "druid"),
@@ -763,7 +763,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
   public void testDatabaseMetaDataColumns() throws SQLException
   {
     final DatabaseMetaData metaData = client.getMetaData();
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             row(
                 Pair.of("TABLE_SCHEM", "druid"),
@@ -841,7 +841,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
   public void testDatabaseMetaDataColumnsOnForbiddenDatasource() throws SQLException
   {
     final DatabaseMetaData metaData = client.getMetaData();
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(),
         getRows(
             metaData.getColumns(null, "dr_id", CalciteTests.FORBIDDEN_DATASOURCE, null),
@@ -854,7 +854,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
   public void testDatabaseMetaDataColumnsWithSuperuser() throws SQLException
   {
     final DatabaseMetaData metaData = superuserClient.getMetaData();
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             row(
                 Pair.of("TABLE_SCHEM", "druid"),
@@ -956,7 +956,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
       throw new RE(e);
     }
     for (int i = 0; i < 2000; i++) {
-      Assert.assertEquals(i + 6, (int) integers.get(i));
+      Assertions.assertEquals(i + 6, (int) integers.get(i));
     }
     exec.shutdown();
   }
@@ -970,11 +970,11 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
       client.createStatement();
     }
 
-    AvaticaClientRuntimeException ex = Assert.assertThrows(
+    AvaticaClientRuntimeException ex = Assertions.assertThrows(
         AvaticaClientRuntimeException.class,
         () -> client.createStatement()
     );
-    Assert.assertTrue(ex.getMessage().contains("Too many open statements, limit is 4"));
+    Assertions.assertTrue(ex.getMessage().contains("Too many open statements, limit is 4"));
   }
 
   @Test
@@ -1000,7 +1000,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
         final ResultSet resultSet = statement.executeQuery(
             "SELECT COUNT(*) AS cnt FROM druid.foo"
         );
-        Assert.assertEquals(
+        Assertions.assertEquals(
             ImmutableList.of(
                 ImmutableMap.of("cnt", 6L)
             ),
@@ -1020,14 +1020,14 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
     try (Statement statement = client.createStatement()) {
       try {
         statement.executeQuery("SELECT SUM(nonexistent) FROM druid.foo");
-        Assert.fail();
+        Assertions.fail();
       }
       catch (Exception e) {
         // Expected
       }
 
       final ResultSet resultSet = statement.executeQuery("SELECT COUNT(*) AS cnt FROM druid.foo");
-      Assert.assertEquals(
+      Assertions.assertEquals(
           ImmutableList.of(ImmutableMap.of("cnt", 6L)),
           getRows(resultSet)
       );
@@ -1044,7 +1044,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
     for (int i = 0; i < 50; i++) {
       try (final Statement statement = client.createStatement()) {
         statement.executeQuery("SELECT SUM(nonexistent) FROM druid.foo");
-        Assert.fail();
+        Assertions.fail();
       }
       catch (Exception e) {
         // Expected
@@ -1058,7 +1058,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
     for (int i = 0; i < 50; i++) {
       try (final Statement statement = client.createStatement()) {
         final ResultSet resultSet = statement.executeQuery("SELECT COUNT(*) AS cnt FROM druid.foo");
-        Assert.assertEquals(
+        Assertions.assertEquals(
             ImmutableList.of(ImmutableMap.of("cnt", 6L)),
             getRows(resultSet)
         );
@@ -1080,11 +1080,11 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
     // codeql[java/database-resource-leak]
     clientNoTrailingSlash.createStatement();
 
-    AvaticaClientRuntimeException ex = Assert.assertThrows(
+    AvaticaClientRuntimeException ex = Assertions.assertThrows(
         AvaticaClientRuntimeException.class,
         () -> server.getUserConnection()
     );
-    Assert.assertTrue(ex.getMessage().contains("Too many connections"));
+    Assertions.assertTrue(ex.getMessage().contains("Too many connections"));
   }
 
   @Test
@@ -1111,7 +1111,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
         final ResultSet resultSet = statement.executeQuery(
             "SELECT COUNT(*) AS cnt FROM druid.foo"
         );
-        Assert.assertTrue(resultSet.next());
+        Assertions.assertTrue(resultSet.next());
       }
     }
   }
@@ -1178,8 +1178,8 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
          final Statement statement = smallFrameClient.createStatement();
          final ResultSet resultSet = statement.executeQuery("SELECT dim1 FROM druid.foo")) {
       final List<Map<String, Object>> rows = getRows(resultSet);
-      Assert.assertEquals(2, frames.size());
-      Assert.assertEquals(
+      Assertions.assertEquals(2, frames.size());
+      Assertions.assertEquals(
           ImmutableList.of(
               ImmutableMap.of("dim1", ""),
               ImmutableMap.of("dim1", "10.1"),
@@ -1225,7 +1225,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
       ) throws NoSuchStatementException, MissingResultsException
       {
         // overriding fetch allows us to track how many frames are processed after the first frame, and also fetch size
-        Assert.assertEquals(config.minRowsPerFrame, fetchMaxRowCount);
+        Assertions.assertEquals(config.minRowsPerFrame, fetchMaxRowCount);
         Frame frame = super.fetch(statement, offset, fetchMaxRowCount);
         frames.add(frame);
         return frame;
@@ -1241,8 +1241,8 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
       try (final ResultSet resultSet = statement.executeQuery()) {
         final List<Map<String, Object>> rows = getRows(resultSet);
         // expect minimum threshold to be used, which should be enough to do this all in first fetch
-        Assert.assertEquals(0, frames.size());
-        Assert.assertEquals(
+        Assertions.assertEquals(0, frames.size());
+        Assertions.assertEquals(
             ImmutableList.of(
                 ImmutableMap.of("dim1", ""),
                 ImmutableMap.of("dim1", "10.1"),
@@ -1270,48 +1270,48 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
         stmt.executeQuery("SELECT COUNT(*) AS cnt FROM druid.foo");
       }
     }
-    Assert.assertEquals(3, testRequestLogger.getSqlQueryLogs().size());
+    Assertions.assertEquals(3, testRequestLogger.getSqlQueryLogs().size());
     for (RequestLogLine logLine : testRequestLogger.getSqlQueryLogs()) {
       final Map<String, Object> stats = logLine.getQueryStats().getStats();
-      Assert.assertEquals(true, stats.get("success"));
-      Assert.assertEquals("regularUser", stats.get("identity"));
-      Assert.assertTrue(stats.containsKey("sqlQuery/time"));
-      Assert.assertTrue(stats.containsKey("sqlQuery/planningTimeMs"));
-      Assert.assertTrue(stats.containsKey("sqlQuery/bytes"));
+      Assertions.assertEquals(true, stats.get("success"));
+      Assertions.assertEquals("regularUser", stats.get("identity"));
+      Assertions.assertTrue(stats.containsKey("sqlQuery/time"));
+      Assertions.assertTrue(stats.containsKey("sqlQuery/planningTimeMs"));
+      Assertions.assertTrue(stats.containsKey("sqlQuery/bytes"));
     }
 
     // invalid sql
     testRequestLogger.clear();
     try (Statement stmt = client.createStatement()) {
       stmt.executeQuery("SELECT notexist FROM druid.foo");
-      Assert.fail("invalid SQL should throw SQLException");
+      Assertions.fail("invalid SQL should throw SQLException");
     }
     catch (SQLException e) {
       // Expected
     }
-    Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
+    Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
     {
       final Map<String, Object> stats = testRequestLogger.getSqlQueryLogs().get(0).getQueryStats().getStats();
-      Assert.assertEquals(false, stats.get("success"));
-      Assert.assertEquals("regularUser", stats.get("identity"));
-      Assert.assertTrue(stats.containsKey("exception"));
+      Assertions.assertEquals(false, stats.get("success"));
+      Assertions.assertEquals("regularUser", stats.get("identity"));
+      Assertions.assertTrue(stats.containsKey("exception"));
     }
 
     // unauthorized sql
     testRequestLogger.clear();
     try (Statement stmt = client.createStatement()) {
       stmt.executeQuery("SELECT count(*) FROM druid.forbiddenDatasource");
-      Assert.fail("unauthorzed SQL should throw SQLException");
+      Assertions.fail("unauthorzed SQL should throw SQLException");
     }
     catch (SQLException e) {
       // Expected
     }
-    Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
+    Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
     {
       final Map<String, Object> stats = testRequestLogger.getSqlQueryLogs().get(0).getQueryStats().getStats();
-      Assert.assertEquals(false, stats.get("success"));
-      Assert.assertEquals("regularUser", stats.get("identity"));
-      Assert.assertTrue(stats.containsKey("exception"));
+      Assertions.assertEquals(false, stats.get("success"));
+      Assertions.assertEquals("regularUser", stats.get("identity"));
+      Assertions.assertTrue(stats.containsKey("exception"));
     }
   }
 
@@ -1325,46 +1325,46 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
         stmt.execute();
       }
     }
-    Assert.assertEquals(6, testRequestLogger.getSqlQueryLogs().size());
+    Assertions.assertEquals(6, testRequestLogger.getSqlQueryLogs().size());
     for (RequestLogLine logLine : testRequestLogger.getSqlQueryLogs()) {
       final Map<String, Object> stats = logLine.getQueryStats().getStats();
-      Assert.assertEquals(true, stats.get("success"));
-      Assert.assertEquals("regularUser", stats.get("identity"));
-      Assert.assertTrue(stats.containsKey("sqlQuery/time"));
-      Assert.assertTrue(stats.containsKey("sqlQuery/planningTimeMs"));
-      Assert.assertTrue(stats.containsKey("sqlQuery/bytes"));
+      Assertions.assertEquals(true, stats.get("success"));
+      Assertions.assertEquals("regularUser", stats.get("identity"));
+      Assertions.assertTrue(stats.containsKey("sqlQuery/time"));
+      Assertions.assertTrue(stats.containsKey("sqlQuery/planningTimeMs"));
+      Assertions.assertTrue(stats.containsKey("sqlQuery/bytes"));
     }
 
     // invalid sql
     testRequestLogger.clear();
     try (PreparedStatement stmt = client.prepareStatement("SELECT notexist FROM druid.foo")) {
-      Assert.fail("invalid SQL should throw SQLException");
+      Assertions.fail("invalid SQL should throw SQLException");
     }
     catch (SQLException e) {
       // Expected
     }
-    Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
+    Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
     {
       final Map<String, Object> stats = testRequestLogger.getSqlQueryLogs().get(0).getQueryStats().getStats();
-      Assert.assertEquals(false, stats.get("success"));
-      Assert.assertEquals("regularUser", stats.get("identity"));
-      Assert.assertTrue(stats.containsKey("exception"));
+      Assertions.assertEquals(false, stats.get("success"));
+      Assertions.assertEquals("regularUser", stats.get("identity"));
+      Assertions.assertTrue(stats.containsKey("exception"));
     }
 
     // unauthorized sql
     testRequestLogger.clear();
     try (PreparedStatement stmt = client.prepareStatement("SELECT count(*) FROM druid.forbiddenDatasource")) {
-      Assert.fail("unauthorzed SQL should throw SQLException");
+      Assertions.fail("unauthorzed SQL should throw SQLException");
     }
     catch (SQLException e) {
       // Expected
     }
-    Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
+    Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
     {
       final Map<String, Object> stats = testRequestLogger.getSqlQueryLogs().get(0).getQueryStats().getStats();
-      Assert.assertEquals(false, stats.get("success"));
-      Assert.assertEquals("regularUser", stats.get("identity"));
-      Assert.assertTrue(stats.containsKey("exception"));
+      Assertions.assertEquals(false, stats.get("success"));
+      Assertions.assertEquals("regularUser", stats.get("identity"));
+      Assertions.assertTrue(stats.containsKey("exception"));
     }
   }
 
@@ -1378,14 +1378,14 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
       statement.setString(2, "def");
       final ResultSet resultSet = statement.executeQuery();
       final List<Map<String, Object>> rows = getRows(resultSet);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           ImmutableList.of(
               ImmutableMap.of("cnt", 2L)
           ),
           rows
       );
-      Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
-      Assert.assertEquals(
+      Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
+      Assertions.assertEquals(
           List.of(
               new ClientSqlParameter(SqlType.VARCHAR.toString(), "abc"),
               new ClientSqlParameter(SqlType.VARCHAR.toString(), "def")
@@ -1402,10 +1402,10 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
              client.prepareStatement("SELECT COUNT(*) AS cnt FROM sys.servers WHERE servers.host = ?")) {
       statement.setString(1, "dummy");
 
-      Assert.assertThrows(
-          "Insufficient permission to view servers",
+      Assertions.assertThrows(
           AvaticaSqlException.class,
-          statement::executeQuery
+          statement::executeQuery,
+          "Insufficient permission to view servers"
       );
     }
   }
@@ -1416,7 +1416,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
     try (PreparedStatement statement =
              superuserClient.prepareStatement("SELECT COUNT(*) AS cnt FROM sys.servers WHERE servers.host = ?")) {
       statement.setString(1, "dummy");
-      Assert.assertEquals(
+      Assertions.assertEquals(
           ImmutableList.of(
               ImmutableMap.of("cnt", 1L)
           ),
@@ -1431,19 +1431,19 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
     try (PreparedStatement statement =
              superuserClient.prepareStatement("SELECT COUNT(*) AS cnt FROM sys.servers WHERE servers.host = ?")) {
       statement.setString(1, "dummy");
-      Assert.assertEquals(
+      Assertions.assertEquals(
           ImmutableList.of(
               ImmutableMap.of("cnt", 1L)
           ),
           getRows(statement.executeQuery())
       );
       statement.setString(1, "foo");
-      Assert.assertEquals(
+      Assertions.assertEquals(
           Collections.emptyList(),
           getRows(statement.executeQuery())
       );
       statement.setString(1, "dummy");
-      Assert.assertEquals(
+      Assertions.assertEquals(
           ImmutableList.of(
               ImmutableMap.of("cnt", 1L)
           ),
@@ -1460,7 +1460,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
           "SELECT COUNT(*) AS cnt FROM druid.lotsocolumns WHERE dimMultivalEnumerated = 'ㅑ ㅓ ㅕ ㅗ ㅛ ㅜ ㅠ ㅡ ㅣ'"
       );
       final List<Map<String, Object>> rows = getRows(resultSet);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           ImmutableList.of(
               ImmutableMap.of("cnt", 1L)
           ),
@@ -1473,7 +1473,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
       statement.setString(1, "ㅑ ㅓ ㅕ ㅗ ㅛ ㅜ ㅠ ㅡ ㅣ");
       final ResultSet resultSet2 = statement.executeQuery();
       final List<Map<String, Object>> rows = getRows(resultSet2);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           ImmutableList.of(
               ImmutableMap.of("cnt", 1L)
           ),
@@ -1531,7 +1531,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
     );
     // If the escape clause wasn't correctly set, rows for potentially none or more than
     // one datasource (some_datasource and somexdatasource) would have been returned
-    Assert.assertEquals(
+    Assertions.assertEquals(
         someDatasourceColumns,
         getRows(
             metaData.getColumns(null, "dr_id", CalciteTests.SOME_DATSOURCE_ESCAPED, null),
@@ -1566,7 +1566,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
             Pair.of("COLUMN_NAME", "unique_dim1_x")
         )
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         someXDatasourceColumns,
         getRows(
             metaData.getColumns(null, "dr_id", "somexdatasource", null),
@@ -1577,7 +1577,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
     List<Map<String, Object>> columnsOfBothTables = new ArrayList<>(someDatasourceColumns);
     columnsOfBothTables.addAll(someXDatasourceColumns);
     // Assert that the pattern matching still works when no escape string is provided
-    Assert.assertEquals(
+    Assertions.assertEquals(
         columnsOfBothTables,
         getRows(
             metaData.getColumns(null, "dr_id", "some_datasource", null),
@@ -1586,7 +1586,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
     );
 
     // Assert column name pattern works correctly when _ is in the column names
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             row(
                 Pair.of("TABLE_SCHEM", "druid"),
@@ -1606,7 +1606,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
     );
 
     // Assert column name pattern with % works correctly for column names starting with m
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             row(
                 Pair.of("TABLE_SCHEM", "druid"),
@@ -1641,7 +1641,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
   {
     final DatabaseMetaData metaData = client.getMetaData();
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             row(
                 Pair.of("TABLE_SCHEM", "druid"),
@@ -1654,7 +1654,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
         )
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             row(
                 Pair.of("TABLE_SCHEM", "druid"),
@@ -1668,7 +1668,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
     );
 
     // Assert that some_datasource is treated as a pattern that matches some_datasource and somexdatasource
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             row(
                 Pair.of("TABLE_SCHEM", "druid"),
@@ -1693,15 +1693,15 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
         "SELECT ARRAY_AGG(dim2) AS arr1, ARRAY_AGG(l1) AS arr2, ARRAY_AGG(dbl1)  AS arr3, ARRAY_AGG(f1) AS arr4 FROM druid.numfoo")) {
       final ResultSet resultSet = statement.executeQuery();
       final List<Map<String, Object>> rows = getRows(resultSet);
-      Assert.assertEquals(1, rows.size());
-      Assert.assertTrue(rows.get(0).containsKey("arr1"));
-      Assert.assertTrue(rows.get(0).containsKey("arr2"));
-      Assert.assertTrue(rows.get(0).containsKey("arr3"));
-      Assert.assertTrue(rows.get(0).containsKey("arr4"));
-      Assert.assertArrayEquals(new Object[]{"a", null, "", "a", "abc", null}, (Object[]) rows.get(0).get("arr1"));
-      Assert.assertArrayEquals(new Object[]{7L, 325323L, 0L, null, null, null}, (Object[]) rows.get(0).get("arr2"));
-      Assert.assertArrayEquals(new Object[]{1.0, 1.7, 0.0, null, null, null}, (Object[]) rows.get(0).get("arr3"));
-      Assert.assertArrayEquals(new Object[]{1.0, 0.10000000149011612, 0.0, null, null, null}, (Object[]) rows.get(0).get("arr4"));
+      Assertions.assertEquals(1, rows.size());
+      Assertions.assertTrue(rows.get(0).containsKey("arr1"));
+      Assertions.assertTrue(rows.get(0).containsKey("arr2"));
+      Assertions.assertTrue(rows.get(0).containsKey("arr3"));
+      Assertions.assertTrue(rows.get(0).containsKey("arr4"));
+      Assertions.assertArrayEquals(new Object[]{"a", null, "", "a", "abc", null}, (Object[]) rows.get(0).get("arr1"));
+      Assertions.assertArrayEquals(new Object[]{7L, 325323L, 0L, null, null, null}, (Object[]) rows.get(0).get("arr2"));
+      Assertions.assertArrayEquals(new Object[]{1.0, 1.7, 0.0, null, null, null}, (Object[]) rows.get(0).get("arr3"));
+      Assertions.assertArrayEquals(new Object[]{1.0, 0.10000000149011612, 0.0, null, null, null}, (Object[]) rows.get(0).get("arr4"));
     }
   }
 
@@ -1718,13 +1718,13 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
       statement.executeQuery(query);
     }
     catch (SQLException e) {
-      Assert.assertEquals(
+      Assertions.assertEquals(
           e.getMessage(),
           expectedError
       );
       return;
     }
-    Assert.fail("Test failed, did not get SQLException");
+    Assertions.fail("Test failed, did not get SQLException");
   }
 
   private static class TestResultFetcher extends ResultFetcher
@@ -1849,15 +1849,15 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
         try (final Statement statement = conn.createStatement();
              final ResultSet resultSet = statement.executeQuery("SELECT dim1 FROM druid.foo")) {
           final List<Map<String, Object>> rows = getRows(resultSet);
-          Assert.assertEquals(6, rows.size());
-          Assert.assertEquals(6, frames.size()); // 3 empty frames and then 3 frames of 2 rows each
-
-          Assert.assertFalse(frames.get(0).rows.iterator().hasNext());
-          Assert.assertFalse(frames.get(1).rows.iterator().hasNext());
-          Assert.assertFalse(frames.get(2).rows.iterator().hasNext());
-          Assert.assertTrue(frames.get(3).rows.iterator().hasNext());
-          Assert.assertTrue(frames.get(4).rows.iterator().hasNext());
-          Assert.assertTrue(frames.get(5).rows.iterator().hasNext());
+          Assertions.assertEquals(6, rows.size());
+          Assertions.assertEquals(6, frames.size()); // 3 empty frames and then 3 frames of 2 rows each
+
+          Assertions.assertFalse(frames.get(0).rows.iterator().hasNext());
+          Assertions.assertFalse(frames.get(1).rows.iterator().hasNext());
+          Assertions.assertFalse(frames.get(2).rows.iterator().hasNext());
+          Assertions.assertTrue(frames.get(3).rows.iterator().hasNext());
+          Assertions.assertTrue(frames.get(4).rows.iterator().hasNext());
+          Assertions.assertTrue(frames.get(5).rows.iterator().hasNext());
         }
       }
 
@@ -1872,12 +1872,12 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
   public void testMultiStatementFails() throws SQLException
   {
     try (Statement stmt = client.createStatement()) {
-      Throwable t = Assert.assertThrows(
+      Throwable t = Assertions.assertThrows(
           AvaticaSqlException.class,
           () -> stmt.executeQuery("SET useApproxCountDistinct = true; SELECT COUNT(DISTINCT dim1) AS cnt FROM druid.foo")
       );
       // ugly error message for statement
-      Assert.assertEquals(
+      Assertions.assertEquals(
           "Error -1 (00000) : Error while executing SQL \"SET useApproxCountDistinct = true; SELECT COUNT(DISTINCT dim1) AS cnt FROM druid.foo\": Remote driver error: QueryInterruptedException: SQL query string must contain only a single statement -> DruidException: SQL query string must contain only a single statement",
           t.getMessage()
       );
@@ -1887,12 +1887,12 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
   @Test
   public void testMultiPreparedStatementFails() throws SQLException
   {
-    Throwable t = Assert.assertThrows(
+    Throwable t = Assertions.assertThrows(
         AvaticaSqlException.class,
         () -> client.prepareStatement("SET vectorize = 'force'; SELECT COUNT(*) AS cnt FROM druid.foo")
     );
     // sad error message for prepared statement
-    Assert.assertEquals(
+    Assertions.assertEquals(
         "Error -1 (00000) : while preparing SQL: SET vectorize = 'force'; SELECT COUNT(*) AS cnt FROM druid.foo",
         t.getMessage()
     );
@@ -1915,11 +1915,11 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
       int count = 0;
       while (iter.hasNext()) {
         Pair<Long, String> row = iter.next();
-        Assert.assertNotNull(row.lhs);
-        Assert.assertNotNull(row.rhs);
+        Assertions.assertNotNull(row.lhs);
+        Assertions.assertNotNull(row.rhs);
         count++;
       }
-      Assert.assertEquals(6, count);
+      Assertions.assertEquals(6, count);
     }
     finally {
       handle.close();
@@ -1982,16 +1982,16 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
       stmt.executeQuery("SELECT COUNT(*) AS cnt FROM druid.foo");
     }
 
-    Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
+    Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
     RequestLogLine logLine = testRequestLogger.getSqlQueryLogs().get(0);
 
     String remoteAddress = logLine.getRemoteAddr();
-    Assert.assertNotNull("Remote address should not be null", remoteAddress);
+    Assertions.assertNotNull(remoteAddress, "Remote address should not be null");
 
-    Assert.assertTrue(
-        "Remote address should be a valid IP address, got: " + remoteAddress,
+    Assertions.assertTrue(
         IPV4_PATTERN.matcher(remoteAddress).matches() ||
-        IPV6_PATTERN.matcher(remoteAddress).matches()
+        IPV6_PATTERN.matcher(remoteAddress).matches(),
+        "Remote address should be a valid IP address, got: " + remoteAddress
     );
   }
 
@@ -2005,18 +2005,18 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
 
     try (Statement stmt = client.createStatement()) {
       stmt.executeQuery("SELECT nonexistent FROM druid.foo");
-      Assert.fail("Query should have failed");
+      Assertions.fail("Query should have failed");
     }
     catch (SQLException e) {
       // Expected exception
     }
 
-    Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
+    Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
     RequestLogLine logLine = testRequestLogger.getSqlQueryLogs().get(0);
 
     String remoteAddress = logLine.getRemoteAddr();
-    Assert.assertNotNull("Remote address should not be null even in failed query", remoteAddress);
-    Assert.assertFalse("Remote address should not be empty even in failed query", remoteAddress.length() == 0);
+    Assertions.assertNotNull(remoteAddress, "Remote address should not be null even in failed query");
+    Assertions.assertFalse(remoteAddress.length() == 0, "Remote address should not be empty even in failed query");
   }
 
   /**
@@ -2035,20 +2035,20 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
       stmt.executeQuery();
     }
 
-    Assert.assertFalse(
-        "Should have at least one log entry",
-        testRequestLogger.getSqlQueryLogs().isEmpty()
+    Assertions.assertFalse(
+        testRequestLogger.getSqlQueryLogs().isEmpty(),
+        "Should have at least one log entry"
     );
 
     for (RequestLogLine logLine : testRequestLogger.getSqlQueryLogs()) {
       String remoteAddress = logLine.getRemoteAddr();
-      Assert.assertNotNull(
-          "Every prepared-statement log entry must carry a remote address",
-          remoteAddress
+      Assertions.assertNotNull(
+          remoteAddress,
+          "Every prepared-statement log entry must carry a remote address"
       );
-      Assert.assertFalse(
-          "Every prepared-statement log entry must carry a non-empty remote address",
-          remoteAddress.isEmpty()
+      Assertions.assertFalse(
+          remoteAddress.isEmpty(),
+          "Every prepared-statement log entry must carry a non-empty remote address"
       );
     }
   }
diff --git a/sql/src/test/java/org/apache/druid/sql/avatica/DruidStatementTest.java b/sql/src/test/java/org/apache/druid/sql/avatica/DruidStatementTest.java
index 8746a78f33e..f942c5ecc41 100644
--- a/sql/src/test/java/org/apache/druid/sql/avatica/DruidStatementTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/avatica/DruidStatementTest.java
@@ -49,9 +49,9 @@ import org.apache.druid.sql.calcite.util.CalciteTestBase;
 import org.apache.druid.sql.calcite.util.CalciteTests;
 import org.apache.druid.sql.calcite.util.QueryFrameworkUtils;
 import org.apache.druid.sql.hook.DruidHookDispatcher;
-import org.junit.Assert;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -162,11 +162,11 @@ public class DruidStatementTest extends CalciteTestBase
       // First frame, ask for all rows.
       statement.execute(queryPlus, -1, null);
       Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           subQueryWithOrderByResults(),
           frame
       );
-      Assert.assertTrue(statement.isDone());
+      Assertions.assertTrue(statement.isDone());
     }
   }
 
@@ -182,14 +182,14 @@ public class DruidStatementTest extends CalciteTestBase
       // First frame, ask for all rows.
       statement.execute(queryPlus, -1, null);
       Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           subQueryWithOrderByResults(),
           frame
       );
-      Assert.assertTrue(statement.isDone());
+      Assertions.assertTrue(statement.isDone());
       try {
         statement.nextFrame(6, 6);
-        Assert.fail();
+        Assertions.fail();
       }
       catch (Exception e) {
         // Expected: can't work with an auto-closed result set.
@@ -206,7 +206,7 @@ public class DruidStatementTest extends CalciteTestBase
     try (final DruidJdbcStatement statement = jdbcStatement()) {
       // Error: no call to execute;
       statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
-      Assert.fail();
+      Assertions.fail();
     }
     catch (Exception e) {
       // Expected
@@ -231,7 +231,7 @@ public class DruidStatementTest extends CalciteTestBase
       statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
       statement.closeResultSet();
       statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
-      Assert.fail();
+      Assertions.fail();
     }
     catch (Exception e) {
       // Expected
@@ -249,20 +249,20 @@ public class DruidStatementTest extends CalciteTestBase
     try (final DruidJdbcStatement statement = jdbcStatement()) {
       statement.execute(queryPlus, -1, null);
       Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           subQueryWithOrderByResults(),
           frame
       );
 
       // Do it again. JDBC says we can reuse statements sequentially.
-      Assert.assertTrue(statement.isDone());
+      Assertions.assertTrue(statement.isDone());
       statement.execute(queryPlus, -1, null);
       frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           subQueryWithOrderByResults(),
           frame
       );
-      Assert.assertTrue(statement.isDone());
+      Assertions.assertTrue(statement.isDone());
     }
   }
 
@@ -294,7 +294,7 @@ public class DruidStatementTest extends CalciteTestBase
       // First frame, ask for all rows.
       statement.execute(queryPlus, -1, null);
       Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           Meta.Frame.create(
               0,
               true,
@@ -315,7 +315,7 @@ public class DruidStatementTest extends CalciteTestBase
           ),
           frame
       );
-      Assert.assertTrue(statement.isDone());
+      Assertions.assertTrue(statement.isDone());
     }
   }
 
@@ -335,23 +335,23 @@ public class DruidStatementTest extends CalciteTestBase
 
       // First frame, ask for 2 rows.
       statement.execute(queryPlus, -1, null);
-      Assert.assertEquals(0, statement.getCurrentOffset());
-      Assert.assertFalse(statement.isDone());
+      Assertions.assertEquals(0, statement.getCurrentOffset());
+      Assertions.assertFalse(statement.isDone());
       Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 2);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           firstFrameResults(),
           frame
       );
-      Assert.assertFalse(statement.isDone());
-      Assert.assertEquals(2, statement.getCurrentOffset());
+      Assertions.assertFalse(statement.isDone());
+      Assertions.assertEquals(2, statement.getCurrentOffset());
 
       // Last frame, ask for all remaining rows.
       frame = statement.nextFrame(2, 10);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           secondFrameResults(),
           frame
       );
-      Assert.assertTrue(statement.isDone());
+      Assertions.assertTrue(statement.isDone());
     }
   }
 
@@ -371,28 +371,28 @@ public class DruidStatementTest extends CalciteTestBase
       // First frame, ask for 2 rows.
       statement.execute(queryPlus, -1, null);
       Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 2);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           firstFrameResults(),
           frame
       );
-      Assert.assertFalse(statement.isDone());
+      Assertions.assertFalse(statement.isDone());
 
       // Do it again. Closes the prior result set.
       statement.execute(queryPlus, -1, null);
       frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 2);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           firstFrameResults(),
           frame
       );
-      Assert.assertFalse(statement.isDone());
+      Assertions.assertFalse(statement.isDone());
 
       // Last frame, ask for all remaining rows.
       frame = statement.nextFrame(2, 10);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           secondFrameResults(),
           frame
       );
-      Assert.assertTrue(statement.isDone());
+      Assertions.assertTrue(statement.isDone());
     }
   }
 
@@ -412,11 +412,11 @@ public class DruidStatementTest extends CalciteTestBase
       // First frame, ask for 2 rows.
       statement.execute(queryPlus, -1, null);
       Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 2);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           firstFrameResults(),
           frame
       );
-      Assert.assertFalse(statement.isDone());
+      Assertions.assertFalse(statement.isDone());
 
       // Leave result set open; close statement.
     }
@@ -472,10 +472,10 @@ public class DruidStatementTest extends CalciteTestBase
   @SuppressWarnings("unchecked")
   private void verifySignature(Meta.Signature signature)
   {
-    Assert.assertEquals(Meta.CursorFactory.ARRAY, signature.cursorFactory);
-    Assert.assertEquals(Meta.StatementType.SELECT, signature.statementType);
-    Assert.assertEquals(SELECT_STAR_FROM_FOO, signature.sql);
-    Assert.assertEquals(
+    Assertions.assertEquals(Meta.CursorFactory.ARRAY, signature.cursorFactory);
+    Assertions.assertEquals(Meta.StatementType.SELECT, signature.statementType);
+    Assertions.assertEquals(SELECT_STAR_FROM_FOO, signature.sql);
+    Assertions.assertEquals(
         Lists.newArrayList(
             Lists.newArrayList("__time", "TIMESTAMP", "java.math.BigDecimal"),
             Lists.newArrayList("dim1", "VARCHAR", "java.lang.String"),
@@ -535,11 +535,11 @@ public class DruidStatementTest extends CalciteTestBase
       // First frame, ask for all rows.
       statement.execute(Collections.emptyList(), null);
       Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           subQueryWithOrderByResults(),
           frame
       );
-      Assert.assertTrue(statement.isDone());
+      Assertions.assertTrue(statement.isDone());
     }
   }
 
@@ -556,20 +556,20 @@ public class DruidStatementTest extends CalciteTestBase
       statement.prepare();
       statement.execute(Collections.emptyList(), null);
       Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           subQueryWithOrderByResults(),
           frame
       );
 
       // Do it again. JDBC says we can reuse prepared statements sequentially.
-      Assert.assertTrue(statement.isDone());
+      Assertions.assertTrue(statement.isDone());
       statement.execute(Collections.emptyList(), null);
       frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           subQueryWithOrderByResults(),
           frame
       );
-      Assert.assertTrue(statement.isDone());
+      Assertions.assertTrue(statement.isDone());
     }
   }
 
@@ -605,7 +605,7 @@ public class DruidStatementTest extends CalciteTestBase
       // Execute many times. First time.
       statement.execute(matchingParams, null);
       Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           expected,
           frame
       );
@@ -613,7 +613,7 @@ public class DruidStatementTest extends CalciteTestBase
       // Again, same value.
       statement.execute(matchingParams, null);
       frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           expected,
           frame
       );
@@ -623,7 +623,7 @@ public class DruidStatementTest extends CalciteTestBase
           Collections.singletonList(
               TypedValue.ofLocal(ColumnMetaData.Rep.STRING, "foo")), null);
       frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           Meta.Frame.create(0, true, Collections.emptyList()),
           frame
       );
diff --git a/sql/src/test/java/org/apache/druid/sql/avatica/ErrorHandlerTest.java b/sql/src/test/java/org/apache/druid/sql/avatica/ErrorHandlerTest.java
index 2efa65d1a7b..274ccd8b750 100644
--- a/sql/src/test/java/org/apache/druid/sql/avatica/ErrorHandlerTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/avatica/ErrorHandlerTest.java
@@ -24,8 +24,8 @@ import org.apache.druid.common.exception.AllowedRegexErrorResponseTransformStrat
 import org.apache.druid.query.QueryException;
 import org.apache.druid.query.QueryInterruptedException;
 import org.apache.druid.server.initialization.ServerConfig;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
 
 public class ErrorHandlerTest
@@ -44,7 +44,7 @@ public class ErrorHandlerTest
     QueryException input = new QueryException("error", "error message", "error class", "host");
 
     RuntimeException output = errorHandler.sanitize(input);
-    Assert.assertNull(output.getMessage());
+    Assertions.assertNull(output.getMessage());
   }
 
   @Test
@@ -55,7 +55,7 @@ public class ErrorHandlerTest
     QueryInterruptedException input = new QueryInterruptedException("error", "error messagez", "error class", "host");
 
     RuntimeException output = errorHandler.sanitize(input);
-    Assert.assertEquals("error messagez", output.getMessage());
+    Assertions.assertEquals("error messagez", output.getMessage());
   }
 
   @Test
@@ -68,7 +68,7 @@ public class ErrorHandlerTest
     Mockito.when(serverConfig.getErrorResponseTransformStrategy())
            .thenReturn(emptyAllowedRegexErrorResponseTransformStrategy);
     ErrorHandler errorHandler = new ErrorHandler(serverConfig);
-    Assert.assertTrue(errorHandler.hasAffectingErrorResponseTransformStrategy());
+    Assertions.assertTrue(errorHandler.hasAffectingErrorResponseTransformStrategy());
   }
 
   @Test
@@ -76,7 +76,7 @@ public class ErrorHandlerTest
   {
     ServerConfig serverConfig = new ServerConfig();
     ErrorHandler errorHandler = new ErrorHandler(serverConfig);
-    Assert.assertFalse(errorHandler.hasAffectingErrorResponseTransformStrategy());
+    Assertions.assertFalse(errorHandler.hasAffectingErrorResponseTransformStrategy());
   }
 
   @Test
@@ -92,6 +92,6 @@ public class ErrorHandlerTest
 
     Exception input = new Exception("message");
     RuntimeException output = errorHandler.sanitize(input);
-    Assert.assertEquals(null, output.getMessage());
+    Assertions.assertEquals(null, output.getMessage());
   }
 }
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/aggregation/SqlAggregationModuleTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/aggregation/SqlAggregationModuleTest.java
index 790c6eae392..e6750df129a 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/aggregation/SqlAggregationModuleTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/aggregation/SqlAggregationModuleTest.java
@@ -25,8 +25,7 @@ import com.google.inject.Key;
 import com.google.inject.TypeLiteral;
 import org.apache.druid.sql.calcite.aggregation.builtin.CountSqlAggregator;
 import org.apache.druid.sql.calcite.util.CalciteTestBase;
-import org.hamcrest.CoreMatchers;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
@@ -35,8 +34,6 @@ import java.util.List;
 import java.util.Set;
 import java.util.stream.Collectors;
 
-import static org.hamcrest.MatcherAssert.assertThat;
-
 public class SqlAggregationModuleTest extends CalciteTestBase
 {
   private SqlAggregationModule target;
@@ -53,14 +50,14 @@ public class SqlAggregationModuleTest extends CalciteTestBase
   public void testDefaultSqlAggregatorsAreBound()
   {
     Set<SqlAggregator> sqlAggregators = injector.getInstance(Key.get(new TypeLiteral<>() {}));
-    Assert.assertNotNull(sqlAggregators);
-    Assert.assertEquals(2, sqlAggregators.size());
+    Assertions.assertNotNull(sqlAggregators);
+    Assertions.assertEquals(2, sqlAggregators.size());
 
     final List<SqlAggregator> aggregators = sqlAggregators.stream()
                                                           .sorted(Comparator.comparing(o -> o.getClass().getName()))
                                                           .collect(Collectors.toList());
 
-    assertThat(aggregators.get(0), CoreMatchers.instanceOf(ApproxCountDistinctSqlAggregator.class));
-    assertThat(aggregators.get(1), CoreMatchers.instanceOf(CountSqlAggregator.class));
+    Assertions.assertInstanceOf(ApproxCountDistinctSqlAggregator.class, aggregators.get(0));
+    Assertions.assertInstanceOf(CountSqlAggregator.class, aggregators.get(1));
   }
 }
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/expression/DruidExpressionTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/expression/DruidExpressionTest.java
index d0a25c59df8..b7389bb9eaa 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/expression/DruidExpressionTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/expression/DruidExpressionTest.java
@@ -25,31 +25,29 @@ import org.apache.druid.math.expr.ExpressionType;
 import org.apache.druid.math.expr.Parser;
 import org.apache.druid.segment.column.ColumnType;
 import org.apache.druid.testing.InitializedNullHandlingTest;
-import org.hamcrest.CoreMatchers;
-import org.hamcrest.MatcherAssert;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 public class DruidExpressionTest extends InitializedNullHandlingTest
 {
   @Test
   public void test_doubleLiteral_asString()
   {
-    Assert.assertEquals("0.0", DruidExpression.doubleLiteral(0));
-    Assert.assertEquals("-2.0", DruidExpression.doubleLiteral(-2));
-    Assert.assertEquals("2.0", DruidExpression.doubleLiteral(2));
-    Assert.assertEquals("2.1", DruidExpression.doubleLiteral(2.1));
-    Assert.assertEquals("2.12345678", DruidExpression.doubleLiteral(2.12345678));
-    Assert.assertEquals("2.2E122", DruidExpression.doubleLiteral(2.2e122));
-    Assert.assertEquals("NaN", DruidExpression.doubleLiteral(Double.NaN));
-    Assert.assertEquals("Infinity", DruidExpression.doubleLiteral(Double.POSITIVE_INFINITY));
-    Assert.assertEquals("-Infinity", DruidExpression.doubleLiteral(Double.NEGATIVE_INFINITY));
+    Assertions.assertEquals("0.0", DruidExpression.doubleLiteral(0));
+    Assertions.assertEquals("-2.0", DruidExpression.doubleLiteral(-2));
+    Assertions.assertEquals("2.0", DruidExpression.doubleLiteral(2));
+    Assertions.assertEquals("2.1", DruidExpression.doubleLiteral(2.1));
+    Assertions.assertEquals("2.12345678", DruidExpression.doubleLiteral(2.12345678));
+    Assertions.assertEquals("2.2E122", DruidExpression.doubleLiteral(2.2e122));
+    Assertions.assertEquals("NaN", DruidExpression.doubleLiteral(Double.NaN));
+    Assertions.assertEquals("Infinity", DruidExpression.doubleLiteral(Double.POSITIVE_INFINITY));
+    Assertions.assertEquals("-Infinity", DruidExpression.doubleLiteral(Double.NEGATIVE_INFINITY));
     //CHECKSTYLE.OFF: Regexp
     // Min/max double are banned by regexp due to often being inappropriate; but they are appropriate here.
-    Assert.assertEquals("4.9E-324", DruidExpression.doubleLiteral(Double.MIN_VALUE));
-    Assert.assertEquals("1.7976931348623157E308", DruidExpression.doubleLiteral(Double.MAX_VALUE));
+    Assertions.assertEquals("4.9E-324", DruidExpression.doubleLiteral(Double.MIN_VALUE));
+    Assertions.assertEquals("1.7976931348623157E308", DruidExpression.doubleLiteral(Double.MAX_VALUE));
     //CHECKSTYLE.ON: Regexp
-    Assert.assertEquals("2.2250738585072014E-308", DruidExpression.doubleLiteral(Double.MIN_NORMAL));
+    Assertions.assertEquals("2.2250738585072014E-308", DruidExpression.doubleLiteral(Double.MIN_NORMAL));
   }
 
   @Test
@@ -75,20 +73,20 @@ public class DruidExpressionTest extends InitializedNullHandlingTest
 
     for (double n : doubles) {
       final Expr expr = Parser.parse(DruidExpression.doubleLiteral(n), ExprMacroTable.nil());
-      Assert.assertTrue(expr.isLiteral());
-      MatcherAssert.assertThat(expr.getLiteralValue(), CoreMatchers.instanceOf(Double.class));
-      Assert.assertEquals(n, (double) expr.getLiteralValue(), 0d);
+      Assertions.assertTrue(expr.isLiteral());
+      Assertions.assertInstanceOf(Double.class, expr.getLiteralValue());
+      Assertions.assertEquals(n, (double) expr.getLiteralValue(), 0d);
     }
   }
 
   @Test
   public void test_longLiteral_asString()
   {
-    Assert.assertEquals("0", DruidExpression.longLiteral(0));
-    Assert.assertEquals("-2", DruidExpression.longLiteral(-2));
-    Assert.assertEquals("2", DruidExpression.longLiteral(2));
-    Assert.assertEquals("9223372036854775807", DruidExpression.longLiteral(Long.MAX_VALUE));
-    Assert.assertEquals("-9223372036854775808", DruidExpression.longLiteral(Long.MIN_VALUE));
+    Assertions.assertEquals("0", DruidExpression.longLiteral(0));
+    Assertions.assertEquals("-2", DruidExpression.longLiteral(-2));
+    Assertions.assertEquals("2", DruidExpression.longLiteral(2));
+    Assertions.assertEquals("9223372036854775807", DruidExpression.longLiteral(Long.MAX_VALUE));
+    Assertions.assertEquals("-9223372036854775808", DruidExpression.longLiteral(Long.MIN_VALUE));
   }
 
   @Test
@@ -104,9 +102,9 @@ public class DruidExpressionTest extends InitializedNullHandlingTest
 
     for (long n : longs) {
       final Expr expr = Parser.parse(DruidExpression.longLiteral(n), ExprMacroTable.nil());
-      Assert.assertTrue(expr.isLiteral());
-      MatcherAssert.assertThat(expr.getLiteralValue(), CoreMatchers.instanceOf(Number.class));
-      Assert.assertEquals(n, ((Number) expr.getLiteralValue()).longValue());
+      Assertions.assertTrue(expr.isLiteral());
+      Assertions.assertInstanceOf(Number.class, expr.getLiteralValue());
+      Assertions.assertEquals(n, ((Number) expr.getLiteralValue()).longValue());
     }
   }
 
@@ -115,8 +113,8 @@ public class DruidExpressionTest extends InitializedNullHandlingTest
   {
     final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.STRING, null));
 
-    Assert.assertEquals(ColumnType.STRING, expression.getDruidType());
-    Assert.assertEquals("null", expression.getExpression());
+    Assertions.assertEquals(ColumnType.STRING, expression.getDruidType());
+    Assertions.assertEquals("null", expression.getExpression());
   }
 
   @Test
@@ -124,8 +122,8 @@ public class DruidExpressionTest extends InitializedNullHandlingTest
   {
     final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.LONG, null));
 
-    Assert.assertEquals(ColumnType.LONG, expression.getDruidType());
-    Assert.assertEquals("null", expression.getExpression());
+    Assertions.assertEquals(ColumnType.LONG, expression.getDruidType());
+    Assertions.assertEquals("null", expression.getExpression());
   }
 
   @Test
@@ -133,8 +131,8 @@ public class DruidExpressionTest extends InitializedNullHandlingTest
   {
     final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.DOUBLE, null));
 
-    Assert.assertEquals(ColumnType.DOUBLE, expression.getDruidType());
-    Assert.assertEquals("null", expression.getExpression());
+    Assertions.assertEquals(ColumnType.DOUBLE, expression.getDruidType());
+    Assertions.assertEquals("null", expression.getExpression());
   }
 
   @Test
@@ -143,8 +141,8 @@ public class DruidExpressionTest extends InitializedNullHandlingTest
     final DruidExpression expression =
         DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.STRING_ARRAY, null));
 
-    Assert.assertEquals(ColumnType.STRING_ARRAY, expression.getDruidType());
-    Assert.assertEquals("null", expression.getExpression());
+    Assertions.assertEquals(ColumnType.STRING_ARRAY, expression.getDruidType());
+    Assertions.assertEquals("null", expression.getExpression());
   }
 
   @Test
@@ -153,9 +151,9 @@ public class DruidExpressionTest extends InitializedNullHandlingTest
     final String s = "abcdé\n \\\" ' \uD83E\uDD20 \txyz";
     final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.STRING, s));
 
-    Assert.assertEquals(ColumnType.STRING, expression.getDruidType());
-    Assert.assertEquals("'abcdé\\u000A \\u005C\\u0022 \\u0027 \\uD83E\\uDD20 \\u0009xyz'", expression.getExpression());
-    Assert.assertEquals(s, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue());
+    Assertions.assertEquals(ColumnType.STRING, expression.getDruidType());
+    Assertions.assertEquals("'abcdé\\u000A \\u005C\\u0022 \\u0027 \\uD83E\\uDD20 \\u0009xyz'", expression.getExpression());
+    Assertions.assertEquals(s, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue());
   }
 
   @Test
@@ -164,9 +162,9 @@ public class DruidExpressionTest extends InitializedNullHandlingTest
     final String s = "";
     final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.STRING, s));
 
-    Assert.assertEquals(ColumnType.STRING, expression.getDruidType());
-    Assert.assertEquals("''", expression.getExpression());
-    Assert.assertEquals(
+    Assertions.assertEquals(ColumnType.STRING, expression.getDruidType());
+    Assertions.assertEquals("''", expression.getExpression());
+    Assertions.assertEquals(
         s,
         Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue()
     );
@@ -177,9 +175,9 @@ public class DruidExpressionTest extends InitializedNullHandlingTest
   {
     final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.LONG, -123));
 
-    Assert.assertEquals(ColumnType.LONG, expression.getDruidType());
-    Assert.assertEquals("-123", expression.getExpression());
-    Assert.assertEquals(-123L, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue());
+    Assertions.assertEquals(ColumnType.LONG, expression.getDruidType());
+    Assertions.assertEquals("-123", expression.getExpression());
+    Assertions.assertEquals(-123L, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue());
   }
 
   @Test
@@ -187,9 +185,9 @@ public class DruidExpressionTest extends InitializedNullHandlingTest
   {
     final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.DOUBLE, -123.4));
 
-    Assert.assertEquals(ColumnType.DOUBLE, expression.getDruidType());
-    Assert.assertEquals("-123.4", expression.getExpression());
-    Assert.assertEquals(-123.4, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue());
+    Assertions.assertEquals(ColumnType.DOUBLE, expression.getDruidType());
+    Assertions.assertEquals("-123.4", expression.getExpression());
+    Assertions.assertEquals(-123.4, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue());
   }
 
   @Test
@@ -197,9 +195,9 @@ public class DruidExpressionTest extends InitializedNullHandlingTest
   {
     final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.DOUBLE, Double.NaN));
 
-    Assert.assertEquals(ColumnType.DOUBLE, expression.getDruidType());
-    Assert.assertEquals("NaN", expression.getExpression());
-    Assert.assertEquals(Double.NaN, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue());
+    Assertions.assertEquals(ColumnType.DOUBLE, expression.getDruidType());
+    Assertions.assertEquals("NaN", expression.getExpression());
+    Assertions.assertEquals(Double.NaN, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue());
   }
 
   @Test
@@ -208,9 +206,9 @@ public class DruidExpressionTest extends InitializedNullHandlingTest
     final DruidExpression expression =
         DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.DOUBLE, Double.NEGATIVE_INFINITY));
 
-    Assert.assertEquals(ColumnType.DOUBLE, expression.getDruidType());
-    Assert.assertEquals("-Infinity", expression.getExpression());
-    Assert.assertEquals(
+    Assertions.assertEquals(ColumnType.DOUBLE, expression.getDruidType());
+    Assertions.assertEquals("-Infinity", expression.getExpression());
+    Assertions.assertEquals(
         Double.NEGATIVE_INFINITY,
         Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue()
     );
@@ -222,9 +220,9 @@ public class DruidExpressionTest extends InitializedNullHandlingTest
     final DruidExpression expression =
         DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.DOUBLE, Double.POSITIVE_INFINITY));
 
-    Assert.assertEquals(ColumnType.DOUBLE, expression.getDruidType());
-    Assert.assertEquals("Infinity", expression.getExpression());
-    Assert.assertEquals(
+    Assertions.assertEquals(ColumnType.DOUBLE, expression.getDruidType());
+    Assertions.assertEquals("Infinity", expression.getExpression());
+    Assertions.assertEquals(
         Double.POSITIVE_INFINITY,
         Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue()
     );
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionTestHelper.java b/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionTestHelper.java
index 7f1ef2400fb..ee7f03e8764 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionTestHelper.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionTestHelper.java
@@ -67,9 +67,10 @@ import org.apache.druid.sql.hook.DruidHookDispatcher;
 import org.easymock.EasyMock;
 import org.joda.time.DateTime;
 import org.joda.time.DateTimeZone;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
 
 import javax.annotation.Nullable;
+
 import java.math.BigDecimal;
 import java.util.Arrays;
 import java.util.Collections;
@@ -334,18 +335,18 @@ public class ExpressionTestHelper
   )
   {
     DruidExpression expression = Expressions.toDruidExpression(PLANNER_CONTEXT, rowSignature, rexNode);
-    Assert.assertNotNull(expression);
+    Assertions.assertNotNull(expression);
     if (deepCompare) {
-      Assert.assertEquals("Expression for: " + rexNode, expectedExpression, expression);
+      Assertions.assertEquals(expectedExpression, expression, "Expression for: " + rexNode);
     } else {
-      Assert.assertEquals("Expression for: " + rexNode, expectedExpression.getExpression(), expression.getExpression());
+      Assertions.assertEquals(expectedExpression.getExpression(), expression.getExpression(), "Expression for: " + rexNode);
     }
 
     ExprEval<?> result = PLANNER_CONTEXT.parseExpression(expression.getExpression())
 
                                         .eval(expressionBindings);
 
-    Assert.assertEquals("Result for: " + rexNode, expectedResult, result.value());
+    Assertions.assertEquals(expectedResult, result.value(), "Result for: " + rexNode);
   }
 
   void testFilter(
@@ -364,7 +365,7 @@ public class ExpressionTestHelper
     );
 
     final DimFilter filter = Expressions.toFilter(PLANNER_CONTEXT, rowSignature, virtualColumnRegistry, rexNode);
-    Assert.assertEquals("Filter for: " + rexNode, expectedFilter, filter);
+    Assertions.assertEquals(expectedFilter, filter, "Filter for: " + rexNode);
 
     final List<VirtualColumn> virtualColumns =
         filter.getRequiredColumns()
@@ -374,12 +375,12 @@ public class ExpressionTestHelper
               .sorted(Comparator.comparing(VirtualColumn::getOutputName))
               .collect(Collectors.toList());
 
-    Assert.assertEquals(
-        "Virtual columns for: " + rexNode,
+    Assertions.assertEquals(
         expectedVirtualColumns.stream()
                               .sorted(Comparator.comparing(VirtualColumn::getOutputName))
                               .collect(Collectors.toList()),
-        virtualColumns
+        virtualColumns,
+        "Virtual columns for: " + rexNode
     );
 
     final ValueMatcher matcher = expectedFilter.toFilter().makeMatcher(
@@ -394,6 +395,6 @@ public class ExpressionTestHelper
         )
     );
 
-    Assert.assertEquals("Result for: " + rexNode, expectedResult, matcher.matches(false));
+    Assertions.assertEquals(expectedResult, matcher.matches(false), "Result for: " + rexNode);
   }
 }
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionsTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionsTest.java
index fe413defa22..ecb6f4d310c 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionsTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionsTest.java
@@ -75,10 +75,9 @@ import org.apache.druid.sql.calcite.planner.DruidTypeSystem;
 import org.apache.druid.sql.calcite.planner.PlannerContext;
 import org.apache.druid.sql.calcite.rel.CannotBuildQueryException;
 import org.apache.druid.sql.calcite.util.CalciteTestBase;
-import org.hamcrest.core.StringContains;
 import org.joda.time.DateTimeZone;
 import org.joda.time.Period;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
@@ -87,8 +86,6 @@ import java.math.BigDecimal;
 import java.util.Collections;
 import java.util.Map;
 
-import static org.hamcrest.MatcherAssert.assertThat;
-
 public class ExpressionsTest extends CalciteTestBase
 {
   private static final RowSignature ROW_SIGNATURE = RowSignature
@@ -1280,7 +1277,7 @@ public class ExpressionsTest extends CalciteTestBase
   {
     final SqlOperator roundFunction = getOperatorConversion(SqlStdOperatorTable.ROUND).calciteOperator();
 
-    Throwable t = Assert.assertThrows(
+    Throwable t = Assertions.assertThrows(
         DruidException.class,
         () -> testHelper.testExpressionString(
             roundFunction,
@@ -1299,7 +1296,7 @@ public class ExpressionsTest extends CalciteTestBase
             "IAE Exception"
         )
     );
-    Assert.assertEquals("Function[round] second argument should be a LONG but got STRING instead", t.getMessage());
+    Assertions.assertEquals("Function[round] second argument should be a LONG but got STRING instead", t.getMessage());
   }
 
   @Test
@@ -2303,7 +2300,7 @@ public class ExpressionsTest extends CalciteTestBase
   @Test
   public void testAbnormalRightWithNegativeNumber()
   {
-    Throwable t = Assert.assertThrows(
+    Throwable t = Assertions.assertThrows(
         DruidException.class,
         () -> testHelper.testExpressionString(
             new RightOperatorConversion().calciteOperator(),
@@ -2315,7 +2312,7 @@ public class ExpressionsTest extends CalciteTestBase
             null
         )
     );
-    Assert.assertEquals("Function[right] needs a positive integer as the second argument", t.getMessage());
+    Assertions.assertEquals("Function[right] needs a positive integer as the second argument", t.getMessage());
   }
 
   @Test
@@ -2375,7 +2372,7 @@ public class ExpressionsTest extends CalciteTestBase
   @Test
   public void testAbnormalLeftWithNegativeNumber()
   {
-    Throwable t = Assert.assertThrows(
+    Throwable t = Assertions.assertThrows(
         DruidException.class,
         () -> testHelper.testExpressionString(
             new LeftOperatorConversion().calciteOperator(),
@@ -2387,7 +2384,7 @@ public class ExpressionsTest extends CalciteTestBase
             null
         )
     );
-    Assert.assertEquals("Function[left] needs a positive integer as the second argument", t.getMessage());
+    Assertions.assertEquals("Function[left] needs a positive integer as the second argument", t.getMessage());
   }
 
   @Test
@@ -2739,12 +2736,12 @@ public class ExpressionsTest extends CalciteTestBase
         false
     );
 
-    CannotBuildQueryException t = Assert.assertThrows(
+    CannotBuildQueryException t = Assertions.assertThrows(
         CannotBuildQueryException.class,
         () -> testHelper.testExpression(rexNode, null, plannerContext)
     );
 
-    assertThat(t.getMessage(), StringContains.containsString("Unexpected OVER expression"));
+    Assertions.assertTrue(t.getMessage().contains("Unexpected OVER expression"));
   }
 
   @Test
@@ -2889,7 +2886,7 @@ public class ExpressionsTest extends CalciteTestBase
         )
     );
 
-    Assert.assertNull(
+    Assertions.assertNull(
         Expressions.calciteLiteralToDruidLiteral(
             plannerContext,
             rexBuilder.makeCast(
@@ -2910,7 +2907,7 @@ public class ExpressionsTest extends CalciteTestBase
       final DruidLiteral actual
   )
   {
-    Assert.assertEquals(
+    Assertions.assertEquals(
         StringUtils.format("%s: %s", expected.type(), expected.value()),
         StringUtils.format("%s: %s", actual.type(), actual.value())
     );
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressMatchExpressionTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressMatchExpressionTest.java
index 2bb0116825a..6a15708b072 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressMatchExpressionTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressMatchExpressionTest.java
@@ -26,7 +26,7 @@ import org.apache.druid.segment.column.ColumnType;
 import org.apache.druid.segment.column.RowSignature;
 import org.apache.druid.sql.calcite.expression.builtin.IPv4AddressMatchOperatorConversion;
 import org.apache.druid.sql.calcite.util.CalciteTestBase;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
@@ -67,7 +67,7 @@ public class IPv4AddressMatchExpressionTest extends CalciteTestBase
   @Test
   public void testTooFewArgs()
   {
-    Throwable t = Assert.assertThrows(
+    Throwable t = Assertions.assertThrows(
         ExpressionValidationException.class,
         () -> testExpression(
             Collections.emptyList(),
@@ -75,7 +75,7 @@ public class IPv4AddressMatchExpressionTest extends CalciteTestBase
             IGNORE_EXPECTED_RESULT
         )
     );
-    Assert.assertEquals("Function[ipv4_match] requires 2 arguments", t.getMessage());
+    Assertions.assertEquals("Function[ipv4_match] requires 2 arguments", t.getMessage());
   }
 
   @Test
@@ -83,7 +83,7 @@ public class IPv4AddressMatchExpressionTest extends CalciteTestBase
   {
     String address = IPV4;
     String subnet = SUBNET_192_168;
-    Throwable t = Assert.assertThrows(
+    Throwable t = Assertions.assertThrows(
         ExpressionValidationException.class,
         () -> testExpression(
             Arrays.asList(
@@ -95,7 +95,7 @@ public class IPv4AddressMatchExpressionTest extends CalciteTestBase
             IGNORE_EXPECTED_RESULT
         )
     );
-    Assert.assertEquals("Function[ipv4_match] requires 2 arguments", t.getMessage());
+    Assertions.assertEquals("Function[ipv4_match] requires 2 arguments", t.getMessage());
   }
 
   @Test
@@ -103,7 +103,7 @@ public class IPv4AddressMatchExpressionTest extends CalciteTestBase
   {
     String address = IPV4;
     String variableName = VAR;
-    Throwable t = Assert.assertThrows(
+    Throwable t = Assertions.assertThrows(
         ExpressionValidationException.class,
         () -> testExpression(
             Arrays.asList(
@@ -114,7 +114,7 @@ public class IPv4AddressMatchExpressionTest extends CalciteTestBase
             IGNORE_EXPECTED_RESULT
         )
     );
-    Assert.assertEquals("Function[ipv4_match] subnet argument must be a literal", t.getMessage());
+    Assertions.assertEquals("Function[ipv4_match] subnet argument must be a literal", t.getMessage());
   }
 
   @Test
@@ -122,7 +122,7 @@ public class IPv4AddressMatchExpressionTest extends CalciteTestBase
   {
     String address = IPV4;
     String invalidSubnet = "192.168.0.1/invalid";
-    Throwable t = Assert.assertThrows(
+    Throwable t = Assertions.assertThrows(
         ExpressionValidationException.class,
         () -> testExpression(
             Arrays.asList(
@@ -133,7 +133,7 @@ public class IPv4AddressMatchExpressionTest extends CalciteTestBase
             IGNORE_EXPECTED_RESULT
         )
     );
-    Assert.assertEquals("Function[ipv4_match] subnet arg has an invalid format: 192.168.0.1/invalid", t.getMessage());
+    Assertions.assertEquals("Function[ipv4_match] subnet arg has an invalid format: 192.168.0.1/invalid", t.getMessage());
   }
 
   @Test
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressParseExpressionTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressParseExpressionTest.java
index 65ea14d8f87..d9f42d23a2d 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressParseExpressionTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressParseExpressionTest.java
@@ -26,7 +26,7 @@ import org.apache.druid.segment.column.ColumnType;
 import org.apache.druid.segment.column.RowSignature;
 import org.apache.druid.sql.calcite.expression.builtin.IPv4AddressParseOperatorConversion;
 import org.apache.druid.sql.calcite.util.CalciteTestBase;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
@@ -58,7 +58,7 @@ public class IPv4AddressParseExpressionTest extends CalciteTestBase
   @Test
   public void testTooFewArgs()
   {
-    Throwable t = Assert.assertThrows(
+    Throwable t = Assertions.assertThrows(
         ExpressionValidationException.class,
         () -> testExpression(
             Collections.emptyList(),
@@ -66,13 +66,13 @@ public class IPv4AddressParseExpressionTest extends CalciteTestBase
             IGNORE_EXPECTED_RESULT
         )
     );
-    Assert.assertEquals("Function[ipv4_parse] requires 1 argument", t.getMessage());
+    Assertions.assertEquals("Function[ipv4_parse] requires 1 argument", t.getMessage());
   }
 
   @Test
   public void testTooManyArgs()
   {
-    Throwable t = Assert.assertThrows(
+    Throwable t = Assertions.assertThrows(
         ExpressionValidationException.class,
         () -> testExpression(
             Arrays.asList(
@@ -83,7 +83,7 @@ public class IPv4AddressParseExpressionTest extends CalciteTestBase
             IGNORE_EXPECTED_RESULT
         )
     );
-    Assert.assertEquals("Function[ipv4_parse] requires 1 argument", t.getMessage());
+    Assertions.assertEquals("Function[ipv4_parse] requires 1 argument", t.getMessage());
   }
 
   @Test
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressStringifyExpressionTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressStringifyExpressionTest.java
index f1844fb940e..a50b92321ad 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressStringifyExpressionTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressStringifyExpressionTest.java
@@ -26,7 +26,7 @@ import org.apache.druid.segment.column.ColumnType;
 import org.apache.druid.segment.column.RowSignature;
 import org.apache.druid.sql.calcite.expression.builtin.IPv4AddressStringifyOperatorConversion;
 import org.apache.druid.sql.calcite.util.CalciteTestBase;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
@@ -59,7 +59,7 @@ public class IPv4AddressStringifyExpressionTest extends CalciteTestBase
   @Test
   public void testTooFewArgs()
   {
-    Throwable t = Assert.assertThrows(
+    Throwable t = Assertions.assertThrows(
         ExpressionValidationException.class,
         () -> testExpression(
             Collections.emptyList(),
@@ -67,13 +67,13 @@ public class IPv4AddressStringifyExpressionTest extends CalciteTestBase
             IGNORE_EXPECTED_RESULT
         )
     );
-    Assert.assertEquals("Function[ipv4_stringify] requires 1 argument", t.getMessage());
+    Assertions.assertEquals("Function[ipv4_stringify] requires 1 argument", t.getMessage());
   }
 
   @Test
   public void testTooManyArgs()
   {
-    Throwable t = Assert.assertThrows(
+    Throwable t = Assertions.assertThrows(
         ExpressionValidationException.class,
         () -> testExpression(
             Arrays.asList(
@@ -84,7 +84,7 @@ public class IPv4AddressStringifyExpressionTest extends CalciteTestBase
             IGNORE_EXPECTED_RESULT
         )
     );
-    Assert.assertEquals("Function[ipv4_stringify] requires 1 argument", t.getMessage());
+    Assertions.assertEquals("Function[ipv4_stringify] requires 1 argument", t.getMessage());
   }
 
   @Test
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/expression/OperatorConversionsTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/expression/OperatorConversionsTest.java
index 20369bfcf05..486e48349b8 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/expression/OperatorConversionsTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/expression/OperatorConversionsTest.java
@@ -38,10 +38,9 @@ import org.apache.calcite.sql.validate.SqlValidator;
 import org.apache.calcite.sql.validate.SqlValidatorScope;
 import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.sql.calcite.planner.DruidTypeSystem;
-import org.junit.Assert;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
 import org.mockito.ArgumentMatchers;
 import org.mockito.Mockito;
 import org.mockito.stubbing.Answer;
@@ -51,11 +50,9 @@ import java.util.List;
 
 public class OperatorConversionsTest
 {
-  public static class DefaultOperandTypeCheckerTest
+  @Nested
+  public class DefaultOperandTypeCheckerTest
   {
-    @Rule
-    public ExpectedException expectedException = ExpectedException.none();
-
     @Test
     public void testGetOperandCountRange()
     {
@@ -67,8 +64,8 @@ public class OperatorConversionsTest
           .literalOperands()
           .build();
       SqlOperandCountRange countRange = typeChecker.getOperandCountRange();
-      Assert.assertEquals(2, countRange.getMin());
-      Assert.assertEquals(3, countRange.getMax());
+      Assertions.assertEquals(2, countRange.getMin());
+      Assertions.assertEquals(3, countRange.getMax());
     }
 
     @Test
@@ -81,9 +78,9 @@ public class OperatorConversionsTest
           .requiredOperandCount(2)
           .literalOperands()
           .build();
-      Assert.assertFalse(typeChecker.isOptional(0));
-      Assert.assertFalse(typeChecker.isOptional(1));
-      Assert.assertTrue(typeChecker.isOptional(2));
+      Assertions.assertFalse(typeChecker.isOptional(0));
+      Assertions.assertFalse(typeChecker.isOptional(1));
+      Assertions.assertTrue(typeChecker.isOptional(2));
     }
 
     @Test
@@ -96,7 +93,7 @@ public class OperatorConversionsTest
           .returnTypeNonNull(SqlTypeName.CHAR)
           .build();
       SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker();
-      Assert.assertTrue(
+      Assertions.assertTrue(
           typeChecker.checkOperandTypes(
               mockCallBinding(
                   function,
@@ -119,7 +116,7 @@ public class OperatorConversionsTest
           .returnTypeNonNull(SqlTypeName.CHAR)
           .build();
       SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker();
-      Assert.assertTrue(
+      Assertions.assertTrue(
           typeChecker.checkOperandTypes(
               mockCallBinding(
                   function,
@@ -141,7 +138,7 @@ public class OperatorConversionsTest
           .returnTypeNonNull(SqlTypeName.CHAR)
           .build();
       SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker();
-      Assert.assertFalse(
+      Assertions.assertFalse(
           typeChecker.checkOperandTypes(
               mockCallBinding(
                   function,
@@ -163,14 +160,15 @@ public class OperatorConversionsTest
           .returnTypeNonNull(SqlTypeName.CHAR)
           .build();
       SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker();
-      expectedException.expect(CalciteContextException.class);
-      expectedException.expectMessage("Argument to function 'testLiteralOperandCheckLiteralThrow' must be a literal");
-      typeChecker.checkOperandTypes(
-          mockCallBinding(
-              function,
-              ImmutableList.of(new OperandSpec(SqlTypeName.INTEGER, false))
+      assertThrowsWithMessage(
+          () -> typeChecker.checkOperandTypes(
+              mockCallBinding(
+                  function,
+                  ImmutableList.of(new OperandSpec(SqlTypeName.INTEGER, false))
+              ),
+              true
           ),
-          true
+          "Argument to function 'testLiteralOperandCheckLiteralThrow' must be a literal"
       );
     }
 
@@ -184,7 +182,7 @@ public class OperatorConversionsTest
           .returnTypeNonNull(SqlTypeName.CHAR)
           .build();
       SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker();
-      Assert.assertTrue(
+      Assertions.assertTrue(
           typeChecker.checkOperandTypes(
               mockCallBinding(
                   function,
@@ -205,7 +203,7 @@ public class OperatorConversionsTest
           .returnTypeNonNull(SqlTypeName.CHAR)
           .build();
       SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker();
-      Assert.assertTrue(
+      Assertions.assertTrue(
           typeChecker.checkOperandTypes(
               mockCallBinding(
                   function,
@@ -214,7 +212,7 @@ public class OperatorConversionsTest
               true
           )
       );
-      Assert.assertTrue(
+      Assertions.assertTrue(
           typeChecker.checkOperandTypes(
               mockCallBinding(
                   function,
@@ -235,7 +233,7 @@ public class OperatorConversionsTest
           .returnTypeNonNull(SqlTypeName.CHAR)
           .build();
       SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker();
-      Assert.assertTrue(
+      Assertions.assertTrue(
           typeChecker.checkOperandTypes(
               mockCallBinding(
                   function,
@@ -259,7 +257,7 @@ public class OperatorConversionsTest
           .returnTypeNonNull(SqlTypeName.CHAR)
           .build();
       SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker();
-      Assert.assertTrue(
+      Assertions.assertTrue(
           typeChecker.checkOperandTypes(
               mockCallBinding(
                   function,
@@ -289,9 +287,9 @@ public class OperatorConversionsTest
               new OperandSpec(SqlTypeName.CHAR, false, true)
           )
       );
-      Assert.assertTrue(typeChecker.checkOperandTypes(binding, true));
+      Assertions.assertTrue(typeChecker.checkOperandTypes(binding, true));
       RelDataType returnType = function.getReturnTypeInference().inferReturnType(binding);
-      Assert.assertFalse(returnType.isNullable());
+      Assertions.assertFalse(returnType.isNullable());
     }
 
     @Test
@@ -310,9 +308,9 @@ public class OperatorConversionsTest
               new OperandSpec(SqlTypeName.CHAR, false, true)
           )
       );
-      Assert.assertTrue(typeChecker.checkOperandTypes(binding, true));
+      Assertions.assertTrue(typeChecker.checkOperandTypes(binding, true));
       RelDataType returnType = function.getReturnTypeInference().inferReturnType(binding);
-      Assert.assertTrue(returnType.isNullable());
+      Assertions.assertTrue(returnType.isNullable());
     }
 
     @Test
@@ -331,9 +329,9 @@ public class OperatorConversionsTest
               new OperandSpec(SqlTypeName.CHAR, false, false)
           )
       );
-      Assert.assertTrue(typeChecker.checkOperandTypes(binding, true));
+      Assertions.assertTrue(typeChecker.checkOperandTypes(binding, true));
       RelDataType returnType = function.getReturnTypeInference().inferReturnType(binding);
-      Assert.assertTrue(returnType.isNullable());
+      Assertions.assertTrue(returnType.isNullable());
     }
 
     @Test
@@ -346,19 +344,18 @@ public class OperatorConversionsTest
           .returnTypeNonNull(SqlTypeName.CHAR)
           .build();
       SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker();
-      expectedException.expect(CalciteContextException.class);
-      expectedException.expectMessage(
-          "Exception in test for operator[testNullForNonNullableOperand]: Illegal use of 'NULL'"
-      );
-      typeChecker.checkOperandTypes(
-          mockCallBinding(
-              function,
-              ImmutableList.of(
-                  new OperandSpec(SqlTypeName.NULL, false),
-                  new OperandSpec(SqlTypeName.INTERVAL_HOUR, false)
-              )
+      assertThrowsWithMessage(
+          () -> typeChecker.checkOperandTypes(
+              mockCallBinding(
+                  function,
+                  ImmutableList.of(
+                      new OperandSpec(SqlTypeName.NULL, false),
+                      new OperandSpec(SqlTypeName.INTERVAL_HOUR, false)
+                  )
+              ),
+              true
           ),
-          true
+          "Exception in test for operator[testNullForNonNullableOperand]: Illegal use of 'NULL'"
       );
     }
 
@@ -372,19 +369,18 @@ public class OperatorConversionsTest
           .returnTypeNonNull(SqlTypeName.CHAR)
           .build();
       SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker();
-      expectedException.expect(CalciteContextException.class);
-      expectedException.expectMessage(
-          "Exception in test for operator[testNullLiteralForNonNullableOperand]: Illegal use of 'NULL'"
-      );
-      typeChecker.checkOperandTypes(
-          mockCallBinding(
-              function,
-              ImmutableList.of(
-                  new OperandSpec(SqlTypeName.NULL, true),
-                  new OperandSpec(SqlTypeName.INTERVAL_HOUR, false)
-              )
+      assertThrowsWithMessage(
+          () -> typeChecker.checkOperandTypes(
+              mockCallBinding(
+                  function,
+                  ImmutableList.of(
+                      new OperandSpec(SqlTypeName.NULL, true),
+                      new OperandSpec(SqlTypeName.INTERVAL_HOUR, false)
+                  )
+              ),
+              true
           ),
-          true
+          "Exception in test for operator[testNullLiteralForNonNullableOperand]: Illegal use of 'NULL'"
       );
     }
 
@@ -398,22 +394,27 @@ public class OperatorConversionsTest
           .returnTypeNonNull(SqlTypeName.CHAR)
           .build();
       SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker();
-      expectedException.expect(CalciteContextException.class);
-      expectedException.expectMessage(
-          "Exception in test for operator[testNonCastableType]: Cannot apply 'testNonCastableType' to arguments of type"
-      );
-      typeChecker.checkOperandTypes(
-          mockCallBinding(
-              function,
-              ImmutableList.of(
-                  new OperandSpec(SqlTypeName.INTEGER, true),
-                  new OperandSpec(SqlTypeName.INTERVAL_HOUR, false)
-              )
+      assertThrowsWithMessage(
+          () -> typeChecker.checkOperandTypes(
+              mockCallBinding(
+                  function,
+                  ImmutableList.of(
+                      new OperandSpec(SqlTypeName.INTEGER, true),
+                      new OperandSpec(SqlTypeName.INTERVAL_HOUR, false)
+                  )
+              ),
+              true
           ),
-          true
+          "Exception in test for operator[testNonCastableType]: Cannot apply 'testNonCastableType' to arguments of type"
       );
     }
 
+    private static void assertThrowsWithMessage(Runnable runnable, String expectedMessage)
+    {
+      final CalciteContextException e = Assertions.assertThrows(CalciteContextException.class, runnable::run);
+      Assertions.assertTrue(e.getMessage().contains(expectedMessage), e.getMessage());
+    }
+
     @Test
     public void testSignatureWithNames()
     {
@@ -426,7 +427,7 @@ public class OperatorConversionsTest
           .build();
       SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker();
 
-      Assert.assertEquals(
+      Assertions.assertEquals(
           "'testSignatureWithNames(<x>, [<y>, [<z>]])'",
           typeChecker.getAllowedSignatures(function, function.getName())
       );
@@ -443,7 +444,7 @@ public class OperatorConversionsTest
           .build();
       SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker();
 
-      Assert.assertEquals(
+      Assertions.assertEquals(
           "'testSignatureWithoutNames(<INTEGER>, [<DATE>, [<ANY>]])'",
           typeChecker.getAllowedSignatures(function, function.getName())
       );
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/external/ExternalTableScanRuleTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/external/ExternalTableScanRuleTest.java
index be939fd58ae..45f83af822c 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/external/ExternalTableScanRuleTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/external/ExternalTableScanRuleTest.java
@@ -43,8 +43,8 @@ import org.apache.druid.sql.calcite.schema.ViewSchema;
 import org.apache.druid.sql.calcite.util.CalciteTests;
 import org.apache.druid.sql.hook.DruidHookDispatcher;
 import org.easymock.EasyMock;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 import java.util.Collections;
 
@@ -93,7 +93,7 @@ public class ExternalTableScanRuleTest
 
     ExternalTableScanRule rule = new ExternalTableScanRule(plannerContext);
     rule.matches(EasyMock.createMock(RelOptRuleCall.class));
-    Assert.assertEquals(
+    Assertions.assertEquals(
         "Cannot use [EXTERN] with SQL engine [native].",
         plannerContext.getPlanningError()
     );
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/filtration/CombineAndSimplifyBoundsTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/filtration/CombineAndSimplifyBoundsTest.java
index 6088ffb6454..3c578f9d44a 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/filtration/CombineAndSimplifyBoundsTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/filtration/CombineAndSimplifyBoundsTest.java
@@ -30,7 +30,7 @@ import org.junit.jupiter.params.provider.MethodSource;
 
 import java.util.List;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class CombineAndSimplifyBoundsTest extends BaseCalciteQueryTest
 {
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/filtration/FiltrationTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/filtration/FiltrationTest.java
index b88c520e522..d6b52f81563 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/filtration/FiltrationTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/filtration/FiltrationTest.java
@@ -27,7 +27,7 @@ import org.apache.druid.segment.column.ColumnHolder;
 import org.apache.druid.segment.column.ColumnType;
 import org.apache.druid.segment.column.RowSignature;
 import org.apache.druid.sql.calcite.util.CalciteTestBase;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 public class FiltrationTest extends CalciteTestBase
@@ -46,12 +46,12 @@ public class FiltrationTest extends CalciteTestBase
         null
     ).optimize(RowSignature.builder().add(ColumnHolder.TIME_COLUMN_NAME, ColumnType.LONG).build());
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(Filtration.eternity()),
         filtration.getIntervals()
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         new NotDimFilter(
             new IntervalDimFilter(
                 ColumnHolder.TIME_COLUMN_NAME,
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/http/SqlQueryTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/http/SqlQueryTest.java
index fc62cb05fba..cbe554667b3 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/http/SqlQueryTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/http/SqlQueryTest.java
@@ -32,7 +32,7 @@ import org.apache.druid.sql.calcite.util.CalciteTestBase;
 import org.apache.druid.sql.http.ResultFormat;
 import org.apache.druid.sql.http.SqlParameter;
 import org.apache.druid.sql.http.SqlQuery;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 public class SqlQueryTest extends CalciteTestBase
@@ -51,7 +51,7 @@ public class SqlQueryTest extends CalciteTestBase
         ImmutableMap.of("useCache", false),
         ImmutableList.of(new SqlParameter(SqlType.INTEGER, 1))
     );
-    Assert.assertEquals(query, JSON_MAPPER.readValue(JSON_MAPPER.writeValueAsString(query), SqlQuery.class));
+    Assertions.assertEquals(query, JSON_MAPPER.readValue(JSON_MAPPER.writeValueAsString(query), SqlQuery.class));
   }
 
   @Test
@@ -79,7 +79,7 @@ public class SqlQueryTest extends CalciteTestBase
 
     final SqlQuery observedSqlQuery =
         JSON_MAPPER.readValue(JSON_MAPPER.writeValueAsString(givenClientSqlQuery), SqlQuery.class);
-    Assert.assertEquals(expectedSqlQuery, observedSqlQuery);
+    Assertions.assertEquals(expectedSqlQuery, observedSqlQuery);
   }
 
   @Test
@@ -107,7 +107,7 @@ public class SqlQueryTest extends CalciteTestBase
 
     final SqlQuery observedSqlQuery =
         JSON_MAPPER.readValue(JSON_MAPPER.writeValueAsString(givenClientSqlQuery), SqlQuery.class);
-    Assert.assertEquals(expectedSqlQuery, observedSqlQuery);
+    Assertions.assertEquals(expectedSqlQuery, observedSqlQuery);
   }
 
   @Test
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserTest.java
index 651b8f712f7..e9019e6f822 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserTest.java
@@ -25,8 +25,8 @@ import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.util.DateString;
 import org.apache.calcite.util.TimestampString;
 import org.apache.druid.error.DruidException;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 public class DruidSqlParserTest
 {
@@ -34,21 +34,21 @@ public class DruidSqlParserTest
   public void test_sqlLiteralToContextValue_null()
   {
     final SqlLiteral literal = SqlLiteral.createNull(SqlParserPos.ZERO);
-    Assert.assertNull(DruidSqlParser.sqlLiteralToContextValue(literal));
+    Assertions.assertNull(DruidSqlParser.sqlLiteralToContextValue(literal));
   }
 
   @Test
   public void test_sqlLiteralToContextValue_string()
   {
     final SqlLiteral literal = SqlLiteral.createCharString("abc", SqlParserPos.ZERO);
-    Assert.assertEquals("abc", DruidSqlParser.sqlLiteralToContextValue(literal));
+    Assertions.assertEquals("abc", DruidSqlParser.sqlLiteralToContextValue(literal));
   }
 
   @Test
   public void test_sqlLiteralToContextValue_stringWithSpecialChars()
   {
     final SqlLiteral literal = SqlLiteral.createCharString("hello\nworld\t\"test\"", SqlParserPos.ZERO);
-    Assert.assertEquals("hello\nworld\t\"test\"", DruidSqlParser.sqlLiteralToContextValue(literal));
+    Assertions.assertEquals("hello\nworld\t\"test\"", DruidSqlParser.sqlLiteralToContextValue(literal));
   }
 
   @Test
@@ -56,14 +56,14 @@ public class DruidSqlParserTest
   {
     // Numbers within Long range are converted to Long.
     final SqlLiteral literal = SqlLiteral.createExactNumeric("42", SqlParserPos.ZERO);
-    Assert.assertEquals(42L, DruidSqlParser.sqlLiteralToContextValue(literal));
+    Assertions.assertEquals(42L, DruidSqlParser.sqlLiteralToContextValue(literal));
   }
 
   @Test
   public void test_sqlLiteralToContextValue_negativeInteger()
   {
     final SqlLiteral literal = SqlLiteral.createExactNumeric("-123", SqlParserPos.ZERO);
-    Assert.assertEquals(-123L, DruidSqlParser.sqlLiteralToContextValue(literal));
+    Assertions.assertEquals(-123L, DruidSqlParser.sqlLiteralToContextValue(literal));
   }
 
   @Test
@@ -71,7 +71,7 @@ public class DruidSqlParserTest
   {
     // Decimals are converted to Double.
     final SqlLiteral literal = SqlLiteral.createExactNumeric("3.14159", SqlParserPos.ZERO);
-    Assert.assertEquals(3.14159, DruidSqlParser.sqlLiteralToContextValue(literal));
+    Assertions.assertEquals(3.14159, DruidSqlParser.sqlLiteralToContextValue(literal));
   }
 
   @Test
@@ -79,28 +79,28 @@ public class DruidSqlParserTest
   {
     // Integers outside Long range are retained as strings.
     final SqlLiteral literal = SqlLiteral.createExactNumeric("123456789012345678901234567890", SqlParserPos.ZERO);
-    Assert.assertEquals("123456789012345678901234567890", DruidSqlParser.sqlLiteralToContextValue(literal));
+    Assertions.assertEquals("123456789012345678901234567890", DruidSqlParser.sqlLiteralToContextValue(literal));
   }
 
   @Test
   public void test_sqlLiteralToContextValue_approximateNumeric()
   {
     final SqlLiteral literal = SqlLiteral.createApproxNumeric("1.23E10", SqlParserPos.ZERO);
-    Assert.assertEquals(1.23E10, DruidSqlParser.sqlLiteralToContextValue(literal));
+    Assertions.assertEquals(1.23E10, DruidSqlParser.sqlLiteralToContextValue(literal));
   }
 
   @Test
   public void test_sqlLiteralToContextValue_booleanTrue()
   {
     final SqlLiteral literal = SqlLiteral.createBoolean(true, SqlParserPos.ZERO);
-    Assert.assertEquals(true, DruidSqlParser.sqlLiteralToContextValue(literal));
+    Assertions.assertEquals(true, DruidSqlParser.sqlLiteralToContextValue(literal));
   }
 
   @Test
   public void test_sqlLiteralToContextValue_booleanFalse()
   {
     final SqlLiteral literal = SqlLiteral.createBoolean(false, SqlParserPos.ZERO);
-    Assert.assertEquals(false, DruidSqlParser.sqlLiteralToContextValue(literal));
+    Assertions.assertEquals(false, DruidSqlParser.sqlLiteralToContextValue(literal));
   }
 
   @Test
@@ -110,7 +110,7 @@ public class DruidSqlParserTest
     final TimestampString timestampString = new TimestampString("2023-01-15 14:30:00");
     final SqlLiteral literal =
         SqlLiteral.createTimestamp(SqlTypeName.TIMESTAMP, timestampString, 0, SqlParserPos.ZERO);
-    Assert.assertEquals("2023-01-15T14:30:00.000Z", DruidSqlParser.sqlLiteralToContextValue(literal));
+    Assertions.assertEquals("2023-01-15T14:30:00.000Z", DruidSqlParser.sqlLiteralToContextValue(literal));
   }
 
   @Test
@@ -119,7 +119,7 @@ public class DruidSqlParserTest
     final TimestampString timestampString = new TimestampString("2023-01-15 14:30:00.123");
     final SqlLiteral literal =
         SqlLiteral.createTimestamp(SqlTypeName.TIMESTAMP, timestampString, 3, SqlParserPos.ZERO);
-    Assert.assertEquals("2023-01-15T14:30:00.123Z", DruidSqlParser.sqlLiteralToContextValue(literal));
+    Assertions.assertEquals("2023-01-15T14:30:00.123Z", DruidSqlParser.sqlLiteralToContextValue(literal));
   }
 
   @Test
@@ -127,29 +127,29 @@ public class DruidSqlParserTest
   {
     final DateString dateString = new DateString("2023-01-15");
     final SqlLiteral literal = SqlLiteral.createDate(dateString, SqlParserPos.ZERO);
-    Assert.assertEquals("2023-01-15T00:00:00.000Z", DruidSqlParser.sqlLiteralToContextValue(literal));
+    Assertions.assertEquals("2023-01-15T00:00:00.000Z", DruidSqlParser.sqlLiteralToContextValue(literal));
   }
 
   @Test
   public void test_sqlLiteralToContextValue_unsupportedType()
   {
     final SqlLiteral literal = SqlLiteral.createSymbol(SqlTypeName.BINARY, SqlParserPos.ZERO);
-    final DruidException exception = Assert.assertThrows(
+    final DruidException exception = Assertions.assertThrows(
         DruidException.class,
         () -> DruidSqlParser.sqlLiteralToContextValue(literal)
     );
-    Assert.assertTrue(exception.getMessage().contains("Unsupported type for SET"));
+    Assertions.assertTrue(exception.getMessage().contains("Unsupported type for SET"));
   }
 
   @Test
   public void testParse_reservedKeywordIdentifier()
   {
-    final DruidException exception = Assert.assertThrows(
+    final DruidException exception = Assertions.assertThrows(
         DruidException.class,
         () -> DruidSqlParser.parse("SELECT start FROM sys.\"segments\" LIMIT 1", false)
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         "Token [start] (line [1], column [8]) is a reserved keyword. "
         + "To use it as an identifier, quote it as [\"start\"]",
         exception.getMessage()
@@ -159,35 +159,35 @@ public class DruidSqlParserTest
   @Test
   public void testParse_reservedKeywordOutsideIdentifierContext()
   {
-    final DruidException exception = Assert.assertThrows(
+    final DruidException exception = Assertions.assertThrows(
         DruidException.class,
         () -> DruidSqlParser.parse("SELECT * FROM foo GROUP ORDER BY x", false)
     );
 
-    Assert.assertFalse(exception.getMessage().contains("is a reserved keyword"));
+    Assertions.assertFalse(exception.getMessage().contains("is a reserved keyword"));
   }
 
   @Test
   public void testParse_expectedReservedKeyword()
   {
-    final DruidException exception = Assert.assertThrows(
+    final DruidException exception = Assertions.assertThrows(
         DruidException.class,
         () -> DruidSqlParser.parse("SELECT a FROM", false)
     );
 
-    Assert.assertFalse(exception.getMessage().contains("is a reserved keyword"));
+    Assertions.assertFalse(exception.getMessage().contains("is a reserved keyword"));
   }
 
   @Test
   public void testParse_reservedKeywordFunctionCall()
   {
     // UNNEST is a reserved keyword, but it appears in a function-call context, not as an identifier.
-    final DruidException exception = Assert.assertThrows(
+    final DruidException exception = Assertions.assertThrows(
         DruidException.class,
         () -> DruidSqlParser.parse("SELECT strlen(unnest(a_int))", false)
     );
 
-    Assert.assertTrue(exception.getMessage().contains("Received an unexpected token"));
-    Assert.assertFalse(exception.getMessage().contains("is a reserved keyword"));
+    Assertions.assertTrue(exception.getMessage().contains("Received an unexpected token"));
+    Assertions.assertFalse(exception.getMessage().contains("is a reserved keyword"));
   }
 }
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserUtilsTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserUtilsTest.java
index b51a106aef9..50cf4cfd824 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserUtilsTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserUtilsTest.java
@@ -48,10 +48,11 @@ import org.hamcrest.MatcherAssert;
 import org.joda.time.DateTime;
 import org.joda.time.DateTimeZone;
 import org.joda.time.Period;
-import org.junit.Assert;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import java.util.Arrays;
 
@@ -60,10 +61,11 @@ public class DruidSqlParserUtilsTest
   /**
    * Sanity checking that the formats of TIME_FLOOR(__time, Period) work as expected
    */
-  @RunWith(Parameterized.class)
-  public static class TimeFloorToGranularityConversionTest
+  @Nested
+  @ParameterizedClass(name = "{1}")
+  @MethodSource("constructorFeeder")
+  public class TimeFloorToGranularityConversionTest
   {
-    @Parameterized.Parameters(name = "{1}")
     public static Iterable<Object[]> constructorFeeder()
     {
       return ImmutableList.of(
@@ -71,8 +73,8 @@ public class DruidSqlParserUtilsTest
       );
     }
 
-    String periodString;
-    Granularity expectedGranularity;
+    private final String periodString;
+    private final Granularity expectedGranularity;
 
     public TimeFloorToGranularityConversionTest(String periodString, Granularity expectedGranularity)
     {
@@ -85,21 +87,22 @@ public class DruidSqlParserUtilsTest
     {
       final SqlNodeList args = new SqlNodeList(SqlParserPos.ZERO);
       args.add(new SqlIdentifier("__time", SqlParserPos.ZERO));
-      args.add(SqlLiteral.createCharString(this.periodString, SqlParserPos.ZERO));
+      args.add(SqlLiteral.createCharString(periodString, SqlParserPos.ZERO));
       final SqlNode timeFloorCall = TimeFloorOperatorConversion.SQL_FUNCTION.createCall(args);
       Granularity actualGranularity = DruidSqlParserUtils.convertSqlNodeToGranularity(
           timeFloorCall);
-      Assert.assertEquals(expectedGranularity, actualGranularity);
+      Assertions.assertEquals(expectedGranularity, actualGranularity);
     }
   }
 
   /**
    * Sanity checking that FLOOR(__time TO TimeUnit()) works as intended with the supported granularities
    */
-  @RunWith(Parameterized.class)
-  public static class FloorToGranularityConversionTest
+  @Nested
+  @ParameterizedClass(name = "{1}")
+  @MethodSource("constructorFeeder")
+  public class FloorToGranularityConversionTest
   {
-    @Parameterized.Parameters(name = "{1}")
     public static Iterable<Object[]> constructorFeeder()
     {
       return ImmutableList.of(
@@ -114,9 +117,9 @@ public class DruidSqlParserUtilsTest
       );
     }
 
-    TimeUnit timeUnit;
-    Period period;
-    Granularity expectedGranularity;
+    private final TimeUnit timeUnit;
+    private final Period period;
+    private final Granularity expectedGranularity;
 
     public FloorToGranularityConversionTest(TimeUnit timeUnit, Period period, Granularity expectedGranularity)
     {
@@ -131,10 +134,10 @@ public class DruidSqlParserUtilsTest
       // parserPos doesn't matter
       final SqlNodeList args = new SqlNodeList(SqlParserPos.ZERO);
       args.add(new SqlIdentifier("__time", SqlParserPos.ZERO));
-      args.add(new SqlIntervalQualifier(this.timeUnit, null, SqlParserPos.ZERO));
+      args.add(new SqlIntervalQualifier(timeUnit, null, SqlParserPos.ZERO));
       final SqlNode floorCall = SqlStdOperatorTable.FLOOR.createCall(args);
       Granularity actualGranularity = DruidSqlParserUtils.convertSqlNodeToGranularity(floorCall);
-      Assert.assertEquals(expectedGranularity, actualGranularity);
+      Assertions.assertEquals(expectedGranularity, actualGranularity);
     }
 
     /**
@@ -145,7 +148,7 @@ public class DruidSqlParserUtilsTest
     {
       SqlNode sqlNode = SqlLiteral.createCharString(timeUnit.name(), SqlParserPos.ZERO);
       Granularity actualGranularity = DruidSqlParserUtils.convertSqlNodeToGranularity(sqlNode);
-      Assert.assertEquals(expectedGranularity, actualGranularity);
+      Assertions.assertEquals(expectedGranularity, actualGranularity);
     }
 
     /**
@@ -156,7 +159,7 @@ public class DruidSqlParserUtilsTest
     {
       SqlNode sqlNode = new SqlIdentifier(period.toString(), SqlParserPos.ZERO);
       Granularity actualGranularity = DruidSqlParserUtils.convertSqlNodeToGranularity(sqlNode);
-      Assert.assertEquals(expectedGranularity, actualGranularity);
+      Assertions.assertEquals(expectedGranularity, actualGranularity);
     }
 
     /**
@@ -167,19 +170,20 @@ public class DruidSqlParserUtilsTest
     {
       SqlNode sqlNode = SqlLiteral.createCharString(period.toString(), SqlParserPos.ZERO);
       Granularity actualGranularity = DruidSqlParserUtils.convertSqlNodeToGranularity(sqlNode);
-      Assert.assertEquals(expectedGranularity, actualGranularity);
+      Assertions.assertEquals(expectedGranularity, actualGranularity);
     }
   }
 
   /**
    * Test class that validates the resolution of "CLUSTERED BY" columns to output columns.
    */
-  public static class ResolveClusteredByColumnsTest
+  @Nested
+  public class ResolveClusteredByColumnsTest
   {
     @Test
     public void testNullClusteredByAndSource()
     {
-      Assert.assertNull(DruidSqlParserUtils.resolveClusteredByColumnsToOutputColumns(null, null));
+      Assertions.assertNull(DruidSqlParserUtils.resolveClusteredByColumnsToOutputColumns(null, null));
     }
 
     @Test
@@ -191,7 +195,7 @@ public class DruidSqlParserUtilsTest
           .add(3, "bar")
           .build();
 
-      Assert.assertNull(
+      Assertions.assertNull(
           DruidSqlParserUtils.resolveClusteredByColumnsToOutputColumns(
               null,
               fields
@@ -214,7 +218,7 @@ public class DruidSqlParserUtilsTest
           new SqlParserPos(0, 3)
       );
       args.add(sqlBasicCall1);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           Arrays.asList("__time", "FOO", "DIM3_ALIAS"),
           DruidSqlParserUtils.resolveClusteredByColumnsToOutputColumns(args, null)
       );
@@ -234,7 +238,7 @@ public class DruidSqlParserUtilsTest
       clusteredByArgs.add(new SqlIdentifier("FOO", SqlParserPos.ZERO));
       clusteredByArgs.add(SqlLiteral.createExactNumeric("3", SqlParserPos.ZERO));
 
-      Assert.assertEquals(
+      Assertions.assertEquals(
           Arrays.asList("__time", "FOO", "BOO"),
           DruidSqlParserUtils.resolveClusteredByColumnsToOutputColumns(clusteredByArgs, sourceFieldMappings)
       );
@@ -261,14 +265,15 @@ public class DruidSqlParserUtilsTest
       clusteredByArgs.add(SqlLiteral.createExactNumeric("5", SqlParserPos.ZERO));
       clusteredByArgs.add(SqlLiteral.createExactNumeric("7", SqlParserPos.ZERO));
 
-      Assert.assertEquals(
+      Assertions.assertEquals(
           Arrays.asList("DIM3_ALIAS", "floor_dim4_time", "DIM5", "TIME_FLOOR(\"timestamps\", 'PT1H')"),
           DruidSqlParserUtils.resolveClusteredByColumnsToOutputColumns(clusteredByArgs, sourceFieldMappings)
       );
     }
   }
 
-  public static class ClusteredByColumnsValidationTest
+  @Nested
+  public class ClusteredByColumnsValidationTest
   {
     /**
      * Tests an empty CLUSTERED BY clause
@@ -340,7 +345,8 @@ public class DruidSqlParserUtilsTest
     }
   }
 
-  public static class FloorToGranularityConversionErrorsTest
+  @Nested
+  public class FloorToGranularityConversionErrorsTest
   {
     /**
      * Tests clause like "PARTITIONED BY CEIL(__time TO DAY)"
@@ -453,7 +459,8 @@ public class DruidSqlParserUtilsTest
     }
   }
 
-  public static class NonParameterizedTests
+  @Nested
+  public class NonParameterizedTests
   {
     private static final DateTimeZone TZ_LOS_ANGELES = DateTimes.inferTzFromString("America/Los_Angeles");
 
@@ -472,7 +479,7 @@ public class DruidSqlParserUtilsTest
           DateTimeZone.UTC
       );
 
-      Assert.assertEquals(String.valueOf(ts.getMillis()), s);
+      Assertions.assertEquals(String.valueOf(ts.getMillis()), s);
     }
 
     @Test
@@ -490,7 +497,7 @@ public class DruidSqlParserUtilsTest
           TZ_LOS_ANGELES
       );
 
-      Assert.assertEquals(String.valueOf(ts.getMillis()), s);
+      Assertions.assertEquals(String.valueOf(ts.getMillis()), s);
     }
 
     @Test
@@ -508,7 +515,7 @@ public class DruidSqlParserUtilsTest
           DateTimeZone.UTC
       );
 
-      Assert.assertEquals(String.valueOf(ts.getMillis()), s);
+      Assertions.assertEquals(String.valueOf(ts.getMillis()), s);
     }
 
     @Test
@@ -526,7 +533,7 @@ public class DruidSqlParserUtilsTest
           TZ_LOS_ANGELES
       );
 
-      Assert.assertEquals(String.valueOf(ts.getMillis()), s);
+      Assertions.assertEquals(String.valueOf(ts.getMillis()), s);
     }
 
     @Test
@@ -543,7 +550,7 @@ public class DruidSqlParserUtilsTest
           DateTimeZone.UTC
       );
 
-      Assert.assertEquals(String.valueOf(ts.getMillis()), s);
+      Assertions.assertEquals(String.valueOf(ts.getMillis()), s);
     }
 
     @Test
@@ -560,7 +567,7 @@ public class DruidSqlParserUtilsTest
           DateTimeZone.UTC
       );
 
-      Assert.assertEquals(String.valueOf(ts.getMillis()), s);
+      Assertions.assertEquals(String.valueOf(ts.getMillis()), s);
     }
 
     @Test
@@ -577,7 +584,7 @@ public class DruidSqlParserUtilsTest
           TZ_LOS_ANGELES
       );
 
-      Assert.assertEquals(String.valueOf(ts.getMillis()), s);
+      Assertions.assertEquals(String.valueOf(ts.getMillis()), s);
     }
 
     @Test
@@ -594,13 +601,13 @@ public class DruidSqlParserUtilsTest
           TZ_LOS_ANGELES
       );
 
-      Assert.assertEquals(String.valueOf(ts.getMillis()), s);
+      Assertions.assertEquals(String.valueOf(ts.getMillis()), s);
     }
 
     @Test
     public void test_parseTimeStampWithTimeZone_unknownTimestamp_invalid()
     {
-      final DruidException e = Assert.assertThrows(
+      final DruidException e = Assertions.assertThrows(
           DruidException.class,
           () -> DruidSqlParserUtils.parseTimeStampWithTimeZone(
               SqlLiteral.createUnknown(
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlUnparseTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlUnparseTest.java
index 0e843b4ca2e..a43b0ee85f7 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlUnparseTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlUnparseTest.java
@@ -23,11 +23,11 @@ import org.apache.calcite.avatica.util.Casing;
 import org.apache.calcite.sql.SqlWriter;
 import org.apache.calcite.sql.dialect.CalciteSqlDialect;
 import org.apache.calcite.sql.pretty.SqlPrettyWriter;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.StringReader;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 /**
  * A class containing unit tests for testing implementations of {@link org.apache.calcite.sql.SqlNode#unparse(SqlWriter, int, int)}
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/CalcitePlannerModuleTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/CalcitePlannerModuleTest.java
index c283a364d1a..ee5a5b718f2 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/CalcitePlannerModuleTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/CalcitePlannerModuleTest.java
@@ -54,13 +54,14 @@ import org.apache.druid.sql.calcite.util.CalciteTestBase;
 import org.easymock.EasyMock;
 import org.easymock.EasyMockExtension;
 import org.easymock.Mock;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 
 import javax.validation.Validation;
 import javax.validation.Validator;
+
 import java.util.Collections;
 import java.util.Optional;
 import java.util.Set;
@@ -154,29 +155,29 @@ public class CalcitePlannerModuleTest extends CalciteTestBase
   public void testDruidOperatorTableIsInjectable()
   {
     DruidOperatorTable operatorTable = injector.getInstance(DruidOperatorTable.class);
-    Assert.assertNotNull(operatorTable);
+    Assertions.assertNotNull(operatorTable);
 
     // Should be a singleton.
     DruidOperatorTable other = injector.getInstance(DruidOperatorTable.class);
-    Assert.assertSame(other, operatorTable);
+    Assertions.assertSame(other, operatorTable);
   }
 
   @Test
   public void testPlannerFactoryIsInjectable()
   {
     PlannerFactory plannerFactory = injector.getInstance(PlannerFactory.class);
-    Assert.assertNotNull(PlannerFactory.class);
+    Assertions.assertNotNull(PlannerFactory.class);
 
     // Should be a singleton.
     PlannerFactory other = injector.getInstance(PlannerFactory.class);
-    Assert.assertSame(other, plannerFactory);
+    Assertions.assertSame(other, plannerFactory);
   }
 
   @Test
   public void testPlannerConfigIsInjected()
   {
     PlannerConfig plannerConfig = injector.getInstance(PlannerConfig.class);
-    Assert.assertNotNull(plannerConfig);
+    Assertions.assertNotNull(plannerConfig);
   }
 
   @Test
@@ -199,7 +200,7 @@ public class CalcitePlannerModuleTest extends CalciteTestBase
     boolean containsCustomRule = injector.getInstance(CalciteRulesManager.class)
                                          .druidConventionRuleSet(context)
                                          .contains(customRule);
-    Assert.assertTrue(containsCustomRule);
+    Assertions.assertTrue(containsCustomRule);
   }
 
   @Test
@@ -239,6 +240,6 @@ public class CalcitePlannerModuleTest extends CalciteTestBase
             .filter(rule -> rule instanceof ProjectMergeRule)
             .map(rule -> (ProjectMergeRule) rule)
             .findAny();
-    Assert.assertTrue(firstProjectMergeRule.isPresent() && firstProjectMergeRule.get().config.bloat() == expectedBloat);
+    Assertions.assertTrue(firstProjectMergeRule.isPresent() && firstProjectMergeRule.get().config.bloat() == expectedBloat);
   }
 }
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/ColumnMappingTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/ColumnMappingTest.java
index a534b81aa06..1bb9e42dbf2 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/ColumnMappingTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/ColumnMappingTest.java
@@ -20,7 +20,7 @@
 package org.apache.druid.sql.calcite.planner;
 
 import nl.jqno.equalsverifier.EqualsVerifier;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 public class ColumnMappingTest
 {
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/ColumnMappingsTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/ColumnMappingsTest.java
index 9ff62b4f16b..4ac524ab82b 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/ColumnMappingsTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/ColumnMappingsTest.java
@@ -20,7 +20,7 @@
 package org.apache.druid.sql.calcite.planner;
 
 import nl.jqno.equalsverifier.EqualsVerifier;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 public class ColumnMappingsTest
 {
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidHintTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidHintTest.java
index bada2ace92c..cfdc598276c 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidHintTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidHintTest.java
@@ -20,19 +20,19 @@
 package org.apache.druid.sql.calcite.planner;
 
 import org.apache.druid.query.JoinAlgorithm;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 public class DruidHintTest
 {
   @Test
   public void testFromString()
   {
-    Assert.assertEquals(DruidHint.DruidJoinHint.fromString("sort_merge").id(), DruidHint.DruidJoinHint.SortMergeJoinHint.SORT_MERGE_JOIN);
-    Assert.assertEquals(DruidHint.DruidJoinHint.fromString("broadcast").id(), DruidHint.DruidJoinHint.BroadcastJoinHint.BROADCAST_JOIN);
-    Assert.assertNull(DruidHint.DruidJoinHint.fromString("hash"));
+    Assertions.assertEquals(DruidHint.DruidJoinHint.fromString("sort_merge").id(), DruidHint.DruidJoinHint.SortMergeJoinHint.SORT_MERGE_JOIN);
+    Assertions.assertEquals(DruidHint.DruidJoinHint.fromString("broadcast").id(), DruidHint.DruidJoinHint.BroadcastJoinHint.BROADCAST_JOIN);
+    Assertions.assertNull(DruidHint.DruidJoinHint.fromString("hash"));
 
-    Assert.assertEquals(DruidHint.DruidJoinHint.fromString("sort_merge").asJoinAlgorithm(), JoinAlgorithm.SORT_MERGE);
-    Assert.assertEquals(DruidHint.DruidJoinHint.fromString("broadcast").asJoinAlgorithm(), JoinAlgorithm.BROADCAST);
+    Assertions.assertEquals(DruidHint.DruidJoinHint.fromString("sort_merge").asJoinAlgorithm(), JoinAlgorithm.SORT_MERGE);
+    Assertions.assertEquals(DruidHint.DruidJoinHint.fromString("broadcast").asJoinAlgorithm(), JoinAlgorithm.BROADCAST);
   }
 }
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidOperatorTableTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidOperatorTableTest.java
index f2a66e46e8f..a2490f71878 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidOperatorTableTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidOperatorTableTest.java
@@ -31,15 +31,15 @@ import org.apache.druid.sql.calcite.expression.OperatorConversions;
 import org.apache.druid.sql.calcite.expression.SqlOperatorConversion;
 import org.apache.druid.sql.calcite.rel.Windowing;
 import org.apache.druid.sql.calcite.table.RowSignatures;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import java.util.stream.Collectors;
 
-import static org.junit.Assert.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 
 public class DruidOperatorTableTest
 {
@@ -48,22 +48,22 @@ public class DruidOperatorTableTest
   {
     DruidOperatorTable operatorTable = new DruidOperatorTable(ImmutableSet.of(), ImmutableSet.of());
     List<SqlOperator> operatorList = operatorTable.getOperatorList();
-    Assert.assertNotNull(operatorList);
-    Assert.assertTrue("Built-in operators should be loaded by default", operatorList.size() > 0);
+    Assertions.assertNotNull(operatorList);
+    Assertions.assertTrue(operatorList.size() > 0, "Built-in operators should be loaded by default");
   }
 
   @Test
   public void testIsFunctionSyntax()
   {
-    Assert.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.FUNCTION));
-    Assert.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.FUNCTION_STAR));
-    Assert.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.FUNCTION_ID));
-    Assert.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.SPECIAL));
-    Assert.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.INTERNAL));
+    Assertions.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.FUNCTION));
+    Assertions.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.FUNCTION_STAR));
+    Assertions.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.FUNCTION_ID));
+    Assertions.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.SPECIAL));
+    Assertions.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.INTERNAL));
 
-    Assert.assertFalse(DruidOperatorTable.isFunctionSyntax(SqlSyntax.BINARY));
-    Assert.assertFalse(DruidOperatorTable.isFunctionSyntax(SqlSyntax.PREFIX));
-    Assert.assertFalse(DruidOperatorTable.isFunctionSyntax(SqlSyntax.POSTFIX));
+    Assertions.assertFalse(DruidOperatorTable.isFunctionSyntax(SqlSyntax.BINARY));
+    Assertions.assertFalse(DruidOperatorTable.isFunctionSyntax(SqlSyntax.PREFIX));
+    Assertions.assertFalse(DruidOperatorTable.isFunctionSyntax(SqlSyntax.POSTFIX));
   }
 
   @Test
@@ -91,15 +91,15 @@ public class DruidOperatorTableTest
 
     DruidOperatorTable operatorTable = new DruidOperatorTable(ImmutableSet.of(), extractionOperators);
     List<SqlOperator> operatorList = operatorTable.getOperatorList();
-    Assert.assertNotNull(operatorList);
-    Assert.assertTrue("We should have at least two operators -- the ones we loaded above plus the built-in"
-                      + " operators that gets loaded by default", operatorList.size() > 2);
+    Assertions.assertNotNull(operatorList);
+    Assertions.assertTrue(operatorList.size() > 2, "We should have at least two operators -- the ones we loaded above plus the built-in"
+                      + " operators that gets loaded by default");
 
-    Assert.assertTrue(operatorList.contains(operator1));
-    Assert.assertTrue(operatorList.contains(operator2));
+    Assertions.assertTrue(operatorList.contains(operator1));
+    Assertions.assertTrue(operatorList.contains(operator2));
 
-    Assert.assertTrue(DruidOperatorTable.isFunctionSyntax(operator1.getSyntax()));
-    Assert.assertFalse(DruidOperatorTable.isFunctionSyntax(operator2.getSyntax()));
+    Assertions.assertTrue(DruidOperatorTable.isFunctionSyntax(operator1.getSyntax()));
+    Assertions.assertFalse(DruidOperatorTable.isFunctionSyntax(operator2.getSyntax()));
   }
 
   @Test
@@ -118,8 +118,8 @@ public class DruidOperatorTableTest
           continue;
         default:
           assertFalse(
-              operator + " allows framing; should be supported or rejected and then exclude from this check",
-              operator.allowsFraming()
+              operator.allowsFraming(),
+              operator + " allows framing; should be supported or rejected and then exclude from this check"
           );
       }
     }
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidRexExecutorTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidRexExecutorTest.java
index f58340d2b89..2f387bdc125 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidRexExecutorTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidRexExecutorTest.java
@@ -61,8 +61,8 @@ import org.apache.druid.sql.hook.DruidHookDispatcher;
 import org.apache.druid.testing.InitializedNullHandlingTest;
 import org.easymock.EasyMock;
 import org.joda.time.DateTimeZone;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 import java.math.BigDecimal;
 import java.util.ArrayList;
@@ -141,9 +141,9 @@ public class DruidRexExecutorTest extends InitializedNullHandlingTest
     DruidRexExecutor rexy = new DruidRexExecutor(PLANNER_CONTEXT);
     List<RexNode> reduced = new ArrayList<>();
     rexy.reduce(rexBuilder, ImmutableList.of(call), reduced);
-    Assert.assertEquals(1, reduced.size());
-    Assert.assertEquals(SqlKind.LITERAL, reduced.get(0).getKind());
-    Assert.assertEquals(new BigDecimal(30L), ((RexLiteral) reduced.get(0)).getValue());
+    Assertions.assertEquals(1, reduced.size());
+    Assertions.assertEquals(SqlKind.LITERAL, reduced.get(0).getKind());
+    Assertions.assertEquals(new BigDecimal(30L), ((RexLiteral) reduced.get(0)).getValue());
   }
 
   @Test
@@ -159,9 +159,9 @@ public class DruidRexExecutorTest extends InitializedNullHandlingTest
     DruidRexExecutor rexy = new DruidRexExecutor(PLANNER_CONTEXT);
     List<RexNode> reduced = new ArrayList<>();
     rexy.reduce(rexBuilder, ImmutableList.of(call), reduced);
-    Assert.assertEquals(1, reduced.size());
-    Assert.assertEquals(SqlKind.LITERAL, reduced.get(0).getKind());
-    Assert.assertEquals(
+    Assertions.assertEquals(1, reduced.size());
+    Assertions.assertEquals(SqlKind.LITERAL, reduced.get(0).getKind());
+    Assertions.assertEquals(
         rexBuilder.makeDateLiteral(
             Calcites.jodaToCalciteDateString(
                 DateTimes.of("2010-01-01"),
@@ -184,9 +184,9 @@ public class DruidRexExecutorTest extends InitializedNullHandlingTest
     DruidRexExecutor rexy = new DruidRexExecutor(PLANNER_CONTEXT);
     List<RexNode> reduced = new ArrayList<>();
     rexy.reduce(rexBuilder, ImmutableList.of(call), reduced);
-    Assert.assertEquals(1, reduced.size());
-    Assert.assertEquals(SqlKind.LITERAL, reduced.get(0).getKind());
-    Assert.assertEquals(
+    Assertions.assertEquals(1, reduced.size());
+    Assertions.assertEquals(SqlKind.LITERAL, reduced.get(0).getKind());
+    Assertions.assertEquals(
         Calcites.jodaToCalciteTimestampLiteral(
             rexBuilder,
             DateTimes.of("2010-01-01T02:03:04Z"),
@@ -209,9 +209,9 @@ public class DruidRexExecutorTest extends InitializedNullHandlingTest
     DruidRexExecutor rexy = new DruidRexExecutor(PLANNER_CONTEXT);
     List<RexNode> reduced = new ArrayList<>();
     rexy.reduce(rexBuilder, ImmutableList.of(call), reduced);
-    Assert.assertEquals(1, reduced.size());
-    Assert.assertEquals(SqlKind.LITERAL, reduced.get(0).getKind());
-    Assert.assertTrue(RexLiteral.isNullLiteral(reduced.get(0)));
+    Assertions.assertEquals(1, reduced.size());
+    Assertions.assertEquals(SqlKind.LITERAL, reduced.get(0).getKind());
+    Assertions.assertTrue(RexLiteral.isNullLiteral(reduced.get(0)));
   }
 
   @Test
@@ -221,9 +221,9 @@ public class DruidRexExecutorTest extends InitializedNullHandlingTest
     RexNode call = rexBuilder.makeCall(OPERATOR);
     List<RexNode> reduced = new ArrayList<>();
     rexy.reduce(rexBuilder, ImmutableList.of(call), reduced);
-    Assert.assertEquals(1, reduced.size());
-    Assert.assertEquals(SqlKind.OTHER_FUNCTION, reduced.get(0).getKind());
-    Assert.assertEquals(
+    Assertions.assertEquals(1, reduced.size());
+    Assertions.assertEquals(SqlKind.OTHER_FUNCTION, reduced.get(0).getKind());
+    Assertions.assertEquals(
         CalciteTestBase.makeExpression(ColumnType.ofComplex("hyperUnique"), "hyper_unique()"),
         Expressions.toDruidExpression(
             PLANNER_CONTEXT,
@@ -243,8 +243,8 @@ public class DruidRexExecutorTest extends InitializedNullHandlingTest
     List<BigDecimal> elements = ImmutableList.of(BigDecimal.valueOf(50.12), BigDecimal.valueOf(12.1));
     RexNode literal = rexBuilder.makeLiteral(elements, arraySqlType, true);
     rexy.reduce(rexBuilder, ImmutableList.of(literal), reduced);
-    Assert.assertEquals(1, reduced.size());
-    Assert.assertEquals(
+    Assertions.assertEquals(1, reduced.size());
+    Assertions.assertEquals(
         DruidExpression.ofExpression(
             ColumnType.DOUBLE_ARRAY,
             DruidExpression.functionCall("array"),
@@ -271,8 +271,8 @@ public class DruidRexExecutorTest extends InitializedNullHandlingTest
     List<BigDecimal> elements = ImmutableList.of(BigDecimal.valueOf(50), BigDecimal.valueOf(12));
     RexNode literal = rexBuilder.makeLiteral(elements, arraySqlType, true);
     rexy.reduce(rexBuilder, ImmutableList.of(literal), reduced);
-    Assert.assertEquals(1, reduced.size());
-    Assert.assertEquals(
+    Assertions.assertEquals(1, reduced.size());
+    Assertions.assertEquals(
         DruidExpression.ofExpression(
             ColumnType.LONG_ARRAY,
             DruidExpression.functionCall("array"),
@@ -300,9 +300,9 @@ public class DruidRexExecutorTest extends InitializedNullHandlingTest
     );
     List<RexNode> reduced = new ArrayList<>();
     rexy.reduce(rexBuilder, ImmutableList.of(call), reduced);
-    Assert.assertEquals(1, reduced.size());
-    Assert.assertEquals(SqlKind.OTHER_FUNCTION, reduced.get(0).getKind());
-    Assert.assertEquals(
+    Assertions.assertEquals(1, reduced.size());
+    Assertions.assertEquals(SqlKind.OTHER_FUNCTION, reduced.get(0).getKind());
+    Assertions.assertEquals(
         DruidExpression.ofExpression(
             ColumnType.STRING,
             DruidExpression.functionCall("string_to_array"),
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/OffsetLimitTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/OffsetLimitTest.java
index c54e46a14dd..f209fc437ae 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/OffsetLimitTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/OffsetLimitTest.java
@@ -21,8 +21,8 @@ package org.apache.druid.sql.calcite.planner;
 
 import com.google.common.collect.ImmutableList;
 import org.apache.druid.java.util.common.StringUtils;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 import java.util.stream.Collectors;
@@ -42,14 +42,7 @@ public class OffsetLimitTest
             final OffsetLimit outer = new OffsetLimit(outerOffset, outerLimit < 0 ? null : (long) outerLimit);
             final OffsetLimit combined = inner.andThen(outer);
 
-            Assert.assertEquals(
-                StringUtils.format(
-                    "innerOffset[%s], innerLimit[%s], outerOffset[%s], outerLimit[%s]",
-                    innerOffset,
-                    innerLimit,
-                    outerOffset,
-                    outerLimit
-                ),
+            Assertions.assertEquals(
                 things.stream()
                       .skip(innerOffset)
                       .limit(innerLimit < 0 ? Long.MAX_VALUE : innerLimit)
@@ -59,7 +52,14 @@ public class OffsetLimitTest
                 things.stream()
                       .skip(combined.getOffset())
                       .limit(combined.hasLimit() ? combined.getLimit() : Long.MAX_VALUE)
-                      .collect(Collectors.toList())
+                      .collect(Collectors.toList()),
+                StringUtils.format(
+                    "innerOffset[%s], innerLimit[%s], outerOffset[%s], outerLimit[%s]",
+                    innerOffset,
+                    innerLimit,
+                    outerOffset,
+                    outerLimit
+                )
             );
           }
         }
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/PlannerConfigTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/PlannerConfigTest.java
index c622f279325..6b3442132aa 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/PlannerConfigTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/PlannerConfigTest.java
@@ -21,8 +21,8 @@ package org.apache.druid.sql.calcite.planner;
 
 import nl.jqno.equalsverifier.EqualsVerifier;
 import nl.jqno.equalsverifier.Warning;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 public class PlannerConfigTest
 {
@@ -30,9 +30,9 @@ public class PlannerConfigTest
   public void testPlannerConfigDefaults()
   {
     PlannerConfig config = new PlannerConfig();
-    Assert.assertFalse(config.isUseLexicographicTopN());
-    Assert.assertTrue(config.isUseApproximateTopN());
-    Assert.assertTrue(config.isUseApproximateCountDistinct());
+    Assertions.assertFalse(config.isUseLexicographicTopN());
+    Assertions.assertTrue(config.isUseApproximateTopN());
+    Assertions.assertTrue(config.isUseApproximateCountDistinct());
   }
 
   @Test
@@ -41,8 +41,8 @@ public class PlannerConfigTest
     PlannerConfig config = PlannerConfig.builder()
                                         .useLexicographicTopN(true)
                                         .build();
-    Assert.assertTrue(config.isUseLexicographicTopN());
-    Assert.assertTrue(config.isUseApproximateTopN());
+    Assertions.assertTrue(config.isUseLexicographicTopN());
+    Assertions.assertTrue(config.isUseApproximateTopN());
   }
 
   @Test
@@ -52,8 +52,8 @@ public class PlannerConfigTest
                                         .useLexicographicTopN(false)
                                         .useApproximateTopN(false)
                                         .build();
-    Assert.assertFalse(config.isUseLexicographicTopN());
-    Assert.assertFalse(config.isUseApproximateTopN());
+    Assertions.assertFalse(config.isUseLexicographicTopN());
+    Assertions.assertFalse(config.isUseApproximateTopN());
   }
 
   @Test
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/TrivialTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/TrivialTest.java
index 613aebfcdfd..d821905315c 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/TrivialTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/TrivialTest.java
@@ -27,8 +27,8 @@ import org.apache.druid.sql.calcite.table.DruidTable;
 import java.util.Collections;
 import java.util.Set;
 
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
  * Test class to reference items that are otherwise unused in this package, and
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidQueryTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidQueryTest.java
index 70d76d4c753..95c95757180 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidQueryTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidQueryTest.java
@@ -38,8 +38,8 @@ import org.apache.druid.sql.calcite.filtration.Filtration;
 import org.apache.druid.sql.calcite.planner.ExpressionParserImpl;
 import org.apache.druid.sql.calcite.util.CalciteTests;
 import org.joda.time.Interval;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 import java.util.Collections;
 
@@ -221,8 +221,8 @@ public class DruidQueryTest
       Interval interval
   )
   {
-    Assert.assertEquals(dataSource, pair.lhs);
-    Assert.assertEquals("dim-filter: " + pair.rhs.getDimFilter(), columnFilter, pair.rhs.getDimFilter());
-    Assert.assertEquals(Collections.singletonList(interval), pair.rhs.getIntervals());
+    Assertions.assertEquals(dataSource, pair.lhs);
+    Assertions.assertEquals(columnFilter, pair.rhs.getDimFilter(), "dim-filter: " + pair.rhs.getDimFilter());
+    Assertions.assertEquals(Collections.singletonList(interval), pair.rhs.getIntervals());
   }
 }
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelTest.java
index 61dcd59ea1d..f342d844acc 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelTest.java
@@ -68,9 +68,9 @@ import org.apache.druid.sql.calcite.rel.logical.DruidUnion;
 import org.apache.druid.sql.calcite.table.DatasourceTable;
 import org.apache.druid.sql.calcite.table.DatasourceTable.PhysicalDatasourceMetadata;
 import org.apache.druid.sql.calcite.table.DruidTable;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 
@@ -118,7 +118,7 @@ public class DruidRelTest
   private PlannerContext mockPlannerContext;
   private DruidQueryRel druidQueryRelNode;
 
-  @Before
+  @BeforeEach
   public void setup() throws Exception
   {
     MockitoAnnotations.openMocks(this);
@@ -154,9 +154,9 @@ public class DruidRelTest
     DruidQuery query = druidQueryRelNode.toDruidQuery(true);
 
     // explain query should return a TableDataSource.
-    Assert.assertEquals(TABLE, queryForExplaining.getDataSource());
+    Assertions.assertEquals(TABLE, queryForExplaining.getDataSource());
     // query should return a RestrictedDataSource.
-    Assert.assertEquals(RESTRICTED, query.getDataSource());
+    Assertions.assertEquals(RESTRICTED, query.getDataSource());
   }
 
   @Test
@@ -180,10 +180,10 @@ public class DruidRelTest
     DruidQuery query = joinRel.toDruidQuery(false);
 
     // Assert
-    Assert.assertEquals(DruidJoinQueryRel.DUMMY_DATA_SOURCE, queryForExplaining.getDataSource());
+    Assertions.assertEquals(DruidJoinQueryRel.DUMMY_DATA_SOURCE, queryForExplaining.getDataSource());
     JoinDataSource dataSource = (JoinDataSource) query.getDataSource();
-    Assert.assertEquals(RESTRICTED, ((QueryDataSource) dataSource.getLeft()).getQuery().getDataSource());
-    Assert.assertEquals(RESTRICTED, ((QueryDataSource) dataSource.getRight()).getQuery().getDataSource());
+    Assertions.assertEquals(RESTRICTED, ((QueryDataSource) dataSource.getLeft()).getQuery().getDataSource());
+    Assertions.assertEquals(RESTRICTED, ((QueryDataSource) dataSource.getRight()).getQuery().getDataSource());
   }
 
   @Test
@@ -204,8 +204,8 @@ public class DruidRelTest
     DruidQuery query = rel.toDruidQuery(false);
 
     // Assert
-    Assert.assertEquals(DruidUnionDataSourceRel.DUMMY_DATA_SOURCE, queryForExplaining.getDataSource());
-    Assert.assertEquals(new UnionDataSource(ImmutableList.of(RESTRICTED, RESTRICTED)), query.getDataSource());
+    Assertions.assertEquals(DruidUnionDataSourceRel.DUMMY_DATA_SOURCE, queryForExplaining.getDataSource());
+    Assertions.assertEquals(new UnionDataSource(ImmutableList.of(RESTRICTED, RESTRICTED)), query.getDataSource());
   }
 
   @Test
@@ -225,8 +225,8 @@ public class DruidRelTest
     DruidQuery query = rel.toDruidQuery(false);
 
     // Assert
-    Assert.assertEquals(DruidOuterQueryRel.DUMMY_DATA_SOURCE, queryForExplaining.getDataSource());
-    Assert.assertEquals(RESTRICTED, ((QueryDataSource) query.getDataSource()).getQuery().getDataSource());
+    Assertions.assertEquals(DruidOuterQueryRel.DUMMY_DATA_SOURCE, queryForExplaining.getDataSource());
+    Assertions.assertEquals(RESTRICTED, ((QueryDataSource) query.getDataSource()).getQuery().getDataSource());
   }
 
   @Test
@@ -253,8 +253,8 @@ public class DruidRelTest
     DruidQuery query = rel.toDruidQuery(false);
 
     // Assert
-    Assert.assertEquals(DruidCorrelateUnnestRel.DUMMY_DATA_SOURCE, queryForExplaining.getDataSource());
-    Assert.assertEquals(RESTRICTED, ((UnnestDataSource) query.getDataSource()).getBase());
+    Assertions.assertEquals(DruidCorrelateUnnestRel.DUMMY_DATA_SOURCE, queryForExplaining.getDataSource());
+    Assertions.assertEquals(RESTRICTED, ((UnnestDataSource) query.getDataSource()).getBase());
   }
 
   @Test
@@ -262,10 +262,10 @@ public class DruidRelTest
   {
     DruidUnnestRel rel = DruidUnnestRel.create(mockRelOptCluster, mockRelTraitSet, ALWAYS_TRUE, mockPlannerContext);
 
-    CannotBuildQueryException e1 = Assert.assertThrows(CannotBuildQueryException.class, rel::toDruidQueryForExplaining);
-    CannotBuildQueryException e2 = Assert.assertThrows(CannotBuildQueryException.class, () -> rel.toDruidQuery(false));
-    Assert.assertEquals("Cannot execute UNNEST directly", e1.getMessage());
-    Assert.assertEquals("Cannot execute UNNEST directly", e2.getMessage());
+    CannotBuildQueryException e1 = Assertions.assertThrows(CannotBuildQueryException.class, rel::toDruidQueryForExplaining);
+    CannotBuildQueryException e2 = Assertions.assertThrows(CannotBuildQueryException.class, () -> rel.toDruidQuery(false));
+    Assertions.assertEquals("Cannot execute UNNEST directly", e1.getMessage());
+    Assertions.assertEquals("Cannot execute UNNEST directly", e2.getMessage());
   }
 
   @Test
@@ -273,11 +273,11 @@ public class DruidRelTest
   {
     DruidUnionRel rel = DruidUnionRel.create(mockPlannerContext, REC_TYPE, ImmutableList.of(druidQueryRelNode), 1000);
 
-    UnsupportedOperationException e1 = Assert.assertThrows(
+    UnsupportedOperationException e1 = Assertions.assertThrows(
         UnsupportedOperationException.class,
         rel::toDruidQueryForExplaining
     );
-    UnsupportedOperationException e2 = Assert.assertThrows(
+    UnsupportedOperationException e2 = Assertions.assertThrows(
         UnsupportedOperationException.class,
         () -> rel.toDruidQuery(false)
     );
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelsTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelsTest.java
index e5daa3471e1..bf0561cda4d 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelsTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelsTest.java
@@ -28,10 +28,11 @@ import org.apache.calcite.util.mapping.MappingType;
 import org.apache.calcite.util.mapping.Mappings;
 import org.apache.druid.sql.calcite.table.DruidTable;
 import org.easymock.EasyMock;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 import javax.annotation.Nullable;
+
 import java.util.List;
 import java.util.function.Consumer;
 
@@ -41,8 +42,8 @@ public class DruidRelsTest
   public void test_isScanOrMapping_scan()
   {
     final DruidRel<?> rel = mockDruidRel(DruidQueryRel.class, PartialDruidQuery.Stage.SCAN, null, null, null);
-    Assert.assertTrue(DruidRels.isScanOrMapping(rel, true));
-    Assert.assertTrue(DruidRels.isScanOrMapping(rel, false));
+    Assertions.assertTrue(DruidRels.isScanOrMapping(rel, true));
+    Assertions.assertTrue(DruidRels.isScanOrMapping(rel, false));
     EasyMock.verify(rel, rel.getPartialDruidQuery());
   }
 
@@ -50,8 +51,8 @@ public class DruidRelsTest
   public void test_isScanOrMapping_scanJoin()
   {
     final DruidRel<?> rel = mockDruidRel(DruidJoinQueryRel.class, PartialDruidQuery.Stage.SCAN, null, null, null);
-    Assert.assertTrue(DruidRels.isScanOrMapping(rel, true));
-    Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+    Assertions.assertTrue(DruidRels.isScanOrMapping(rel, true));
+    Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
     EasyMock.verify(rel, rel.getPartialDruidQuery());
   }
 
@@ -59,8 +60,8 @@ public class DruidRelsTest
   public void test_isScanOrMapping_scanUnion()
   {
     final DruidRel<?> rel = mockDruidRel(DruidUnionDataSourceRel.class, PartialDruidQuery.Stage.SCAN, null, null, null);
-    Assert.assertTrue(DruidRels.isScanOrMapping(rel, true));
-    Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+    Assertions.assertTrue(DruidRels.isScanOrMapping(rel, true));
+    Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
     EasyMock.verify(rel, rel.getPartialDruidQuery());
   }
 
@@ -68,8 +69,8 @@ public class DruidRelsTest
   public void test_isScanOrMapping_scanQuery()
   {
     final DruidRel<?> rel = mockDruidRel(DruidOuterQueryRel.class, PartialDruidQuery.Stage.SCAN, null, null, null);
-    Assert.assertFalse(DruidRels.isScanOrMapping(rel, true));
-    Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+    Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true));
+    Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
     EasyMock.verify(rel, rel.getPartialDruidQuery());
   }
 
@@ -84,8 +85,8 @@ public class DruidRelsTest
         project,
         null
     );
-    Assert.assertTrue(DruidRels.isScanOrMapping(rel, true));
-    Assert.assertTrue(DruidRels.isScanOrMapping(rel, false));
+    Assertions.assertTrue(DruidRels.isScanOrMapping(rel, true));
+    Assertions.assertTrue(DruidRels.isScanOrMapping(rel, false));
 
     EasyMock.verify(rel, rel.getPartialDruidQuery(), project);
   }
@@ -101,8 +102,8 @@ public class DruidRelsTest
         project,
         null
     );
-    Assert.assertTrue(DruidRels.isScanOrMapping(rel, true));
-    Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+    Assertions.assertTrue(DruidRels.isScanOrMapping(rel, true));
+    Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
 
     EasyMock.verify(rel, rel.getPartialDruidQuery(), project);
   }
@@ -118,8 +119,8 @@ public class DruidRelsTest
         project,
         null
     );
-    Assert.assertTrue(DruidRels.isScanOrMapping(rel, true));
-    Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+    Assertions.assertTrue(DruidRels.isScanOrMapping(rel, true));
+    Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
 
     EasyMock.verify(rel, rel.getPartialDruidQuery(), project);
   }
@@ -135,8 +136,8 @@ public class DruidRelsTest
         project,
         null
     );
-    Assert.assertFalse(DruidRels.isScanOrMapping(rel, true));
-    Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+    Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true));
+    Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
 
     EasyMock.verify(rel, rel.getPartialDruidQuery(), project);
   }
@@ -152,8 +153,8 @@ public class DruidRelsTest
         project,
         null
     );
-    Assert.assertFalse(DruidRels.isScanOrMapping(rel, true));
-    Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+    Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true));
+    Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
 
     EasyMock.verify(rel, rel.getPartialDruidQuery(), project);
   }
@@ -169,8 +170,8 @@ public class DruidRelsTest
         project,
         null
     );
-    Assert.assertFalse(DruidRels.isScanOrMapping(rel, true));
-    Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+    Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true));
+    Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
 
     EasyMock.verify(rel, rel.getPartialDruidQuery(), project);
   }
@@ -186,8 +187,8 @@ public class DruidRelsTest
         project,
         null
     );
-    Assert.assertFalse(DruidRels.isScanOrMapping(rel, true));
-    Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+    Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true));
+    Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
 
     EasyMock.verify(rel, rel.getPartialDruidQuery(), project);
   }
@@ -203,8 +204,8 @@ public class DruidRelsTest
         project,
         mockFilter()
     );
-    Assert.assertFalse(DruidRels.isScanOrMapping(rel, true));
-    Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+    Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true));
+    Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
 
     EasyMock.verify(rel, rel.getPartialDruidQuery(), project);
   }
@@ -220,8 +221,8 @@ public class DruidRelsTest
         project,
         mockFilter()
     );
-    Assert.assertFalse(DruidRels.isScanOrMapping(rel, true));
-    Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+    Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true));
+    Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
 
     EasyMock.verify(rel, rel.getPartialDruidQuery(), project);
   }
@@ -237,8 +238,8 @@ public class DruidRelsTest
         project,
         mockFilter()
     );
-    Assert.assertFalse(DruidRels.isScanOrMapping(rel, true));
-    Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+    Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true));
+    Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
 
     EasyMock.verify(rel, rel.getPartialDruidQuery(), project);
   }
@@ -253,8 +254,8 @@ public class DruidRelsTest
         null,
         mockFilter()
     );
-    Assert.assertFalse(DruidRels.isScanOrMapping(rel, true));
-    Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+    Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true));
+    Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
 
     EasyMock.verify(rel, rel.getPartialDruidQuery());
   }
@@ -269,8 +270,8 @@ public class DruidRelsTest
         null,
         mockFilter()
     );
-    Assert.assertFalse(DruidRels.isScanOrMapping(rel, true));
-    Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+    Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true));
+    Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
 
     EasyMock.verify(rel, rel.getPartialDruidQuery());
   }
@@ -293,8 +294,8 @@ public class DruidRelsTest
           null
       );
 
-      Assert.assertEquals(stage.toString(), okStages.contains(stage), DruidRels.isScanOrMapping(rel, true));
-      Assert.assertEquals(stage.toString(), okStages.contains(stage), DruidRels.isScanOrMapping(rel, false));
+      Assertions.assertEquals(okStages.contains(stage), DruidRels.isScanOrMapping(rel, true), stage.toString());
+      Assertions.assertEquals(okStages.contains(stage), DruidRels.isScanOrMapping(rel, false), stage.toString());
 
       EasyMock.verify(rel, rel.getPartialDruidQuery(), project);
     }
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rel/GroupingTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rel/GroupingTest.java
index eb4d64b4537..1fed2871140 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/rel/GroupingTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/rel/GroupingTest.java
@@ -24,7 +24,7 @@ import nl.jqno.equalsverifier.EqualsVerifier;
 import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.segment.column.ColumnType;
 import org.apache.druid.sql.calcite.expression.DruidExpression;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 public class GroupingTest
 {
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidJoinRuleTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidJoinRuleTest.java
index c4312b0ae25..1546e5b98d1 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidJoinRuleTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidJoinRuleTest.java
@@ -34,9 +34,9 @@ import org.apache.druid.query.JoinAlgorithm;
 import org.apache.druid.query.QueryContext;
 import org.apache.druid.sql.calcite.planner.DruidTypeSystem;
 import org.apache.druid.sql.calcite.planner.PlannerContext;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
 
 import java.math.BigDecimal;
@@ -66,7 +66,7 @@ public class DruidJoinRuleTest
 
   private DruidJoinRule druidJoinRule;
 
-  @Before
+  @BeforeEach
   public void setup()
   {
     PlannerContext plannerContext = Mockito.mock(PlannerContext.class);
@@ -78,7 +78,7 @@ public class DruidJoinRuleTest
   @Test
   public void test_canHandleCondition_leftEqRight()
   {
-    Assert.assertTrue(
+    Assertions.assertTrue(
         druidJoinRule.canHandleCondition(
             rexBuilder.makeCall(
                 SqlStdOperatorTable.EQUALS,
@@ -97,7 +97,7 @@ public class DruidJoinRuleTest
   @Test
   public void test_canHandleCondition_leftFnEqRight()
   {
-    Assert.assertTrue(
+    Assertions.assertTrue(
         druidJoinRule.canHandleCondition(
             rexBuilder.makeCall(
                 SqlStdOperatorTable.EQUALS,
@@ -120,7 +120,7 @@ public class DruidJoinRuleTest
   @Test
   public void test_canHandleCondition_leftEqRightFn()
   {
-    Assert.assertTrue(
+    Assertions.assertTrue(
         druidJoinRule.canHandleCondition(
             rexBuilder.makeCall(
                 SqlStdOperatorTable.EQUALS,
@@ -144,7 +144,7 @@ public class DruidJoinRuleTest
   public void test_canHandleCondition_leftEqLeft()
   {
 
-    Assert.assertTrue(
+    Assertions.assertTrue(
         druidJoinRule.canHandleCondition(
             rexBuilder.makeCall(
                 SqlStdOperatorTable.EQUALS,
@@ -163,7 +163,7 @@ public class DruidJoinRuleTest
   @Test
   public void test_canHandleCondition_rightEqRight()
   {
-    Assert.assertTrue(
+    Assertions.assertTrue(
         druidJoinRule.canHandleCondition(
             rexBuilder.makeCall(
                 SqlStdOperatorTable.EQUALS,
@@ -182,7 +182,7 @@ public class DruidJoinRuleTest
   @Test
   public void test_canHandleCondition_leftEqRightFn_leftJoin()
   {
-    Assert.assertFalse(
+    Assertions.assertFalse(
         druidJoinRule.canHandleCondition(
             rexBuilder.makeCall(
                 SqlStdOperatorTable.EQUALS,
@@ -205,7 +205,7 @@ public class DruidJoinRuleTest
   @Test
   public void test_canHandleCondition_leftEqRightFn_systemFields()
   {
-    Assert.assertFalse(
+    Assertions.assertFalse(
         druidJoinRule.canHandleCondition(
             rexBuilder.makeCall(
                 SqlStdOperatorTable.EQUALS,
@@ -228,7 +228,7 @@ public class DruidJoinRuleTest
   @Test
   public void test_canHandleCondition_true()
   {
-    Assert.assertTrue(
+    Assertions.assertTrue(
         druidJoinRule.canHandleCondition(
             rexBuilder.makeLiteral(true),
             leftType,
@@ -243,7 +243,7 @@ public class DruidJoinRuleTest
   @Test
   public void test_canHandleCondition_false()
   {
-    Assert.assertTrue(
+    Assertions.assertTrue(
         druidJoinRule.canHandleCondition(
             rexBuilder.makeLiteral(false),
             leftType,
@@ -260,8 +260,8 @@ public class DruidJoinRuleTest
   {
     final List<RexNode> rexNodes = DruidJoinRule.decomposeAnd(rexBuilder.makeInputRef(leftType, 0));
 
-    Assert.assertEquals(1, rexNodes.size());
-    Assert.assertEquals(rexBuilder.makeInputRef(leftType, 0), Iterables.getOnlyElement(rexNodes));
+    Assertions.assertEquals(1, rexNodes.size());
+    Assertions.assertEquals(rexBuilder.makeInputRef(leftType, 0), Iterables.getOnlyElement(rexNodes));
   }
 
   @Test
@@ -283,7 +283,7 @@ public class DruidJoinRuleTest
         )
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             rexBuilder.makeExactLiteral(BigDecimal.valueOf(1)),
             rexBuilder.makeExactLiteral(BigDecimal.valueOf(2)),
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidLogicalValuesRuleTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidLogicalValuesRuleTest.java
index 54619b5b10b..63d3cbaf63e 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidLogicalValuesRuleTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidLogicalValuesRuleTest.java
@@ -36,14 +36,13 @@ import org.apache.druid.sql.calcite.planner.PlannerContext;
 import org.apache.druid.testing.InitializedNullHandlingTest;
 import org.joda.time.DateTime;
 import org.joda.time.DateTimeZone;
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.mockito.Mockito;
 
 import java.math.BigDecimal;
@@ -52,10 +51,11 @@ public class DruidLogicalValuesRuleTest
 {
   private static final PlannerContext DEFAULT_CONTEXT = Mockito.mock(PlannerContext.class);
 
-  @RunWith(Parameterized.class)
-  public static class GetValueFromLiteralSimpleTypesTest extends InitializedNullHandlingTest
+  @Nested
+  @ParameterizedClass(name = "{1}, {2}")
+  @MethodSource("constructorFeeder")
+  public class GetValueFromLiteralSimpleTypesTest extends InitializedNullHandlingTest
   {
-    @Parameters(name = "{1}, {2}")
     public static Iterable<Object[]> constructorFeeder()
     {
       return ImmutableList.of(
@@ -87,8 +87,8 @@ public class DruidLogicalValuesRuleTest
     {
       final RexLiteral literal = Mockito.spy(makeLiteral(val, sqlTypeName, javaType));
       final Object fromLiteral = DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT);
-      Assert.assertSame(javaType, fromLiteral.getClass());
-      Assert.assertEquals(val, fromLiteral);
+      Assertions.assertSame(javaType, fromLiteral.getClass());
+      Assertions.assertEquals(val, fromLiteral);
       Mockito.verify(literal, Mockito.times(1)).getType();
     }
 
@@ -106,18 +106,17 @@ public class DruidLogicalValuesRuleTest
     }
   }
 
-  public static class GetValueFromLiteralOtherTypesTest
+  @Nested
+  @TestInstance(TestInstance.Lifecycle.PER_CLASS)
+  public class GetValueFromLiteralOtherTypesTest
   {
     private static final PlannerContext DEFAULT_CONTEXT = Mockito.mock(PlannerContext.class);
     private static final DateTimeZone TIME_ZONE = DateTimes.inferTzFromString("Asia/Seoul");
     private static final RelDataTypeFactory TYPE_FACTORY = new SqlTypeFactoryImpl(DruidTypeSystem.INSTANCE);
     private static final RexBuilder REX_BUILDER = new RexBuilder(TYPE_FACTORY);
 
-    @Rule
-    public ExpectedException expectedException = ExpectedException.none();
-
-    @BeforeClass
-    public static void setup()
+    @BeforeAll
+    public void setup()
     {
       Mockito.when(DEFAULT_CONTEXT.getTimeZone()).thenReturn(TIME_ZONE);
     }
@@ -128,8 +127,8 @@ public class DruidLogicalValuesRuleTest
       RexLiteral literal = REX_BUILDER.makeLiteral(true);
 
       final Object fromLiteral = DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT);
-      Assert.assertSame(Long.class, fromLiteral.getClass());
-      Assert.assertEquals(1L, fromLiteral);
+      Assertions.assertSame(Long.class, fromLiteral.getClass());
+      Assertions.assertEquals(1L, fromLiteral);
     }
 
     @Test
@@ -138,8 +137,8 @@ public class DruidLogicalValuesRuleTest
       RexLiteral literal = REX_BUILDER.makeLiteral(false);
 
       final Object fromLiteral = DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT);
-      Assert.assertSame(Long.class, fromLiteral.getClass());
-      Assert.assertEquals(0L, fromLiteral);
+      Assertions.assertSame(Long.class, fromLiteral.getClass());
+      Assertions.assertEquals(0L, fromLiteral);
     }
 
     @Test
@@ -148,7 +147,7 @@ public class DruidLogicalValuesRuleTest
       RexLiteral literal = REX_BUILDER.makeLiteral(null, REX_BUILDER.getTypeFactory().createSqlType(SqlTypeName.BOOLEAN));
 
       final Object fromLiteral = DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT);
-      Assert.assertNull(fromLiteral);
+      Assertions.assertNull(fromLiteral);
     }
 
     @Test
@@ -157,8 +156,8 @@ public class DruidLogicalValuesRuleTest
       RexLiteral literal = REX_BUILDER.makeTimestampLiteral(new TimestampString("2021-04-01 16:54:31"), 0);
 
       final Object fromLiteral = DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT);
-      Assert.assertSame(Long.class, fromLiteral.getClass());
-      Assert.assertEquals(new DateTime("2021-04-01T16:54:31", TIME_ZONE).getMillis(), fromLiteral);
+      Assertions.assertSame(Long.class, fromLiteral.getClass());
+      Assertions.assertEquals(new DateTime("2021-04-01T16:54:31", TIME_ZONE).getMillis(), fromLiteral);
     }
 
     @Test
@@ -167,8 +166,8 @@ public class DruidLogicalValuesRuleTest
       RexLiteral literal = REX_BUILDER.makeDateLiteral(new DateString("2021-04-01"));
 
       final Object fromLiteral = DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT);
-      Assert.assertSame(Long.class, fromLiteral.getClass());
-      Assert.assertEquals(new DateTime("2021-04-01", TIME_ZONE).getMillis(), fromLiteral);
+      Assertions.assertSame(Long.class, fromLiteral.getClass());
+      Assertions.assertEquals(new DateTime("2021-04-01", TIME_ZONE).getMillis(), fromLiteral);
     }
 
     @Test
@@ -178,42 +177,36 @@ public class DruidLogicalValuesRuleTest
           new TimestampString("2021-04-01 16:54:31"),
           0
       );
-      expectedException.expect(
-          DruidExceptionMatcher
-              .invalidSqlInput()
-              .expectMessageIs(
-                  "Cannot handle literal [2021-04-01 16:54:31:TIMESTAMP_WITH_LOCAL_TIME_ZONE(0)] "
-                  + "of unsupported type [TIMESTAMP_WITH_LOCAL_TIME_ZONE]."
-              )
-      );
-      DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT);
+      DruidExceptionMatcher
+          .invalidSqlInput()
+          .expectMessageIs(
+              "Cannot handle literal [2021-04-01 16:54:31:TIMESTAMP_WITH_LOCAL_TIME_ZONE(0)] "
+              + "of unsupported type [TIMESTAMP_WITH_LOCAL_TIME_ZONE]."
+          )
+          .assertThrowsAndMatches(() -> DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT));
     }
 
     @Test
     public void testGetValueFromTimeLiteral()
     {
       RexLiteral literal = REX_BUILDER.makeTimeLiteral(new TimeString("16:54:31"), 0);
-      expectedException.expect(
-          DruidExceptionMatcher
-              .invalidSqlInput()
-              .expectMessageIs("Cannot handle literal [16:54:31] of unsupported type [TIME].")
-      );
-      DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT);
+      DruidExceptionMatcher
+          .invalidSqlInput()
+          .expectMessageIs("Cannot handle literal [16:54:31] of unsupported type [TIME].")
+          .assertThrowsAndMatches(() -> DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT));
     }
 
     @Test
     public void testGetValueFromTimeWithLocalTimeZoneLiteral()
     {
       RexLiteral literal = REX_BUILDER.makeTimeWithLocalTimeZoneLiteral(new TimeString("16:54:31"), 0);
-      expectedException.expect(
-          DruidExceptionMatcher
-              .invalidSqlInput()
-              .expectMessageIs(
-                  "Cannot handle literal [16:54:31:TIME_WITH_LOCAL_TIME_ZONE(0)] "
-                  + "of unsupported type [TIME_WITH_LOCAL_TIME_ZONE]."
-              )
-      );
-      DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT);
+      DruidExceptionMatcher
+          .invalidSqlInput()
+          .expectMessageIs(
+              "Cannot handle literal [16:54:31:TIME_WITH_LOCAL_TIME_ZONE(0)] "
+              + "of unsupported type [TIME_WITH_LOCAL_TIME_ZONE]."
+          )
+          .assertThrowsAndMatches(() -> DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT));
     }
 
     @Test
@@ -224,7 +217,7 @@ public class DruidLogicalValuesRuleTest
           TYPE_FACTORY.createSqlType(SqlTypeName.INTEGER)
       );
       Object value = DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT);
-      Assert.assertEquals(value, 123L);
+      Assertions.assertEquals(value, 123L);
     }
   }
 }
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidUnionDataSourceRuleTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidUnionDataSourceRuleTest.java
index 9d6bad13bd5..4cb21c16011 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidUnionDataSourceRuleTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidUnionDataSourceRuleTest.java
@@ -36,8 +36,8 @@ import org.apache.druid.sql.calcite.table.DatasourceTable;
 import org.apache.druid.sql.calcite.table.DatasourceTable.PhysicalDatasourceMetadata;
 import org.apache.druid.sql.calcite.table.DruidTable;
 import org.easymock.EasyMock;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 import java.util.Arrays;
 import java.util.List;
@@ -69,7 +69,7 @@ public class DruidUnionDataSourceRuleTest
         null
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         Optional.of(ImmutableList.of("__time", "col1", "col2")),
         DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null)
     );
@@ -86,7 +86,7 @@ public class DruidUnionDataSourceRuleTest
         null
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         Optional.of(ImmutableList.of("col1")),
         DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null)
     );
@@ -103,7 +103,7 @@ public class DruidUnionDataSourceRuleTest
         null
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         Optional.empty(),
         DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null)
     );
@@ -120,7 +120,7 @@ public class DruidUnionDataSourceRuleTest
         DruidRelsTest.mockFilter()
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         Optional.empty(),
         DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null)
     );
@@ -138,7 +138,7 @@ public class DruidUnionDataSourceRuleTest
         null
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         Optional.of(ImmutableList.of("__time", "col1", "col2")),
         DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null)
     );
@@ -165,7 +165,7 @@ public class DruidUnionDataSourceRuleTest
         null
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         Optional.of(ImmutableList.of("col2", "col1")),
         DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null)
     );
@@ -183,7 +183,7 @@ public class DruidUnionDataSourceRuleTest
         null
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         Optional.of(ImmutableList.of("__time", "col1", "col2")),
         DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null)
     );
@@ -200,7 +200,7 @@ public class DruidUnionDataSourceRuleTest
         null
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         Optional.empty(),
         DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null)
     );
@@ -217,7 +217,7 @@ public class DruidUnionDataSourceRuleTest
         null
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         Optional.empty(),
         DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null)
     );
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rule/FilterDecomposeConcatRuleTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rule/FilterDecomposeConcatRuleTest.java
index bbce9836607..acd83de6ede 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/rule/FilterDecomposeConcatRuleTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/rule/FilterDecomposeConcatRuleTest.java
@@ -30,8 +30,8 @@ import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.druid.sql.calcite.expression.builtin.ConcatOperatorConversion;
 import org.apache.druid.sql.calcite.planner.DruidTypeSystem;
 import org.apache.druid.testing.InitializedNullHandlingTest;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 import java.math.BigDecimal;
 import java.util.Arrays;
@@ -51,7 +51,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
             literal("2")
         );
 
-    Assert.assertEquals(call, shuttle.apply(call));
+    Assertions.assertEquals(call, shuttle.apply(call));
   }
 
   @Test
@@ -60,7 +60,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
     final RexNode concatCall =
         concat(literal("it's "), inputRef(0));
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         and(equals(inputRef(0), literal("2"))),
         shuttle.apply(equals(concatCall, literal("it's 2")))
     );
@@ -72,7 +72,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
     final RexNode concatCall =
         concat(literal("it's "), inputRef(0));
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         and(equals(inputRef(0), literal("2"))),
         shuttle.apply(equals(literal("it's 2"), concatCall))
     );
@@ -83,7 +83,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
   {
     final RexNode concatCall = concat(inputRef(0));
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         and(equals(inputRef(0), literal("it's 2"))),
         shuttle.apply(equals(literal("it's 2"), concatCall))
     );
@@ -95,7 +95,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
     final RexNode concatCall =
         concat(inputRef(0), literal("x"), inputRef(1));
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         and(equals(inputRef(0), literal("2")), equals(inputRef(1), literal("3"))),
         shuttle.apply(equals(concatCall, literal("2x3")))
     );
@@ -116,7 +116,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
     final RexNode concatCall =
         concat(numericInputRef, literal("x"), inputRef(1));
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         and(
             equals(
                 numericInputRef,
@@ -140,7 +140,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
             literal("2x3")
         );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         rexBuilder.makeCall(
             SqlStdOperatorTable.NOT,
             and(equals(inputRef(0), literal("2")), equals(inputRef(1), literal("3")))
@@ -160,7 +160,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
     final RexNode concatCall =
         concat(inputRef(0), three, inputRef(1), literal("4"));
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         and(equals(inputRef(0), literal("x")), equals(inputRef(1), literal("y"))),
         shuttle.apply(equals(concatCall, literal("x3y4")))
     );
@@ -170,7 +170,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
   public void test_twoInputs_noLiteral()
   {
     final RexNode call = equals(concat(inputRef(0), inputRef(1)), literal("2x3"));
-    Assert.assertEquals(call, shuttle.apply(call));
+    Assertions.assertEquals(call, shuttle.apply(call));
   }
 
   @Test
@@ -179,7 +179,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
     final RexNode call =
         isNull(concat(inputRef(0), literal("x"), inputRef(1)));
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         or(isNull(inputRef(0)), isNull(inputRef(1))),
         shuttle.apply(call)
     );
@@ -191,7 +191,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
     final RexNode call =
         notNull(concat(inputRef(0), literal("x"), inputRef(1)));
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         rexBuilder.makeCall(
             SqlStdOperatorTable.NOT,
             or(isNull(inputRef(0)), isNull(inputRef(1)))
@@ -209,7 +209,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
             literal("2xx3") // ambiguous match
         );
 
-    Assert.assertEquals(call, shuttle.apply(call));
+    Assertions.assertEquals(call, shuttle.apply(call));
   }
 
   @Test
@@ -222,7 +222,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
         );
 
     final RexLiteral unknown = rexBuilder.makeNullLiteral(typeFactory.createSqlType(SqlTypeName.BOOLEAN));
-    Assert.assertEquals(
+    Assertions.assertEquals(
         or(
             and(isNull(inputRef(0)), unknown),
             and(isNull(inputRef(1)), unknown)
@@ -241,7 +241,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
         );
 
     final RexLiteral unknown = rexBuilder.makeNullLiteral(typeFactory.createSqlType(SqlTypeName.BOOLEAN));
-    Assert.assertEquals(
+    Assertions.assertEquals(
         or(
             and(isNull(inputRef(0)), unknown),
             and(isNull(inputRef(1)), unknown)
@@ -259,7 +259,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
             literal("23") // must be recognized as ambiguous
         );
 
-    Assert.assertEquals(call, shuttle.apply(call));
+    Assertions.assertEquals(call, shuttle.apply(call));
   }
 
   @Test
@@ -271,7 +271,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
             literal("2---3") // must be recognized as ambiguous
         );
 
-    Assert.assertEquals(call, shuttle.apply(call));
+    Assertions.assertEquals(call, shuttle.apply(call));
   }
 
   @Test
@@ -284,7 +284,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
         );
 
     final RexLiteral unknown = rexBuilder.makeNullLiteral(typeFactory.createSqlType(SqlTypeName.BOOLEAN));
-    Assert.assertEquals(
+    Assertions.assertEquals(
         or(
             and(isNull(inputRef(0)), unknown),
             and(isNull(inputRef(1)), unknown)
@@ -302,7 +302,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
             literal("xxx (4x5)") // unambiguous, because 'x' before ' (' can be ignored
         );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         and(
             equals(inputRef(0), literal("xxx")),
             equals(inputRef(1), literal("4")),
@@ -318,7 +318,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
     final RexNode concatCall =
         concat(inputRef(0), literal("x"), literal("y"), inputRef(1));
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         and(equals(inputRef(0), literal("2")), equals(inputRef(1), literal("3"))),
         shuttle.apply(equals(concatCall, literal("2xy3")))
     );
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rule/FilterJoinExcludePushToChildRuleTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rule/FilterJoinExcludePushToChildRuleTest.java
index 48843fc2760..9f9c503aa5b 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/rule/FilterJoinExcludePushToChildRuleTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/rule/FilterJoinExcludePushToChildRuleTest.java
@@ -29,8 +29,8 @@ import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.type.SqlTypeFactoryImpl;
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.druid.sql.calcite.planner.DruidTypeSystem;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -57,16 +57,16 @@ public class FilterJoinExcludePushToChildRuleTest
     joinFilters.add(equalityFilter);
 
     FilterJoinExcludePushToChildRule.removeRedundantIsNotNullFilters(joinFilters, JoinRelType.INNER);
-    Assert.assertEquals(joinFilters.size(), 1);
-    Assert.assertEquals("Equality Filter changed", joinFilters.get(0), equalityFilter);
+    Assertions.assertEquals(joinFilters.size(), 1);
+    Assertions.assertEquals(joinFilters.get(0), equalityFilter, "Equality Filter changed");
 
     // add IS NOT NULL filter on a join column
     joinFilters.add(isNotNullFilterOnNonJoinColumn);
     joinFilters.add(isNotNullFilterOnJoinColumn);
-    Assert.assertEquals(joinFilters.size(), 3);
+    Assertions.assertEquals(joinFilters.size(), 3);
     FilterJoinExcludePushToChildRule.removeRedundantIsNotNullFilters(joinFilters, JoinRelType.INNER);
-    Assert.assertEquals(joinFilters.size(), 2);
-    Assert.assertEquals("Equality Filter changed", joinFilters.get(0), equalityFilter);
-    Assert.assertEquals("IS NOT NULL filter on non-join column changed", joinFilters.get(1), isNotNullFilterOnNonJoinColumn);
+    Assertions.assertEquals(joinFilters.size(), 2);
+    Assertions.assertEquals(joinFilters.get(0), equalityFilter, "Equality Filter changed");
+    Assertions.assertEquals(joinFilters.get(1), isNotNullFilterOnNonJoinColumn, "IS NOT NULL filter on non-join column changed");
   }
 }
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/run/DruidHookTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/run/DruidHookTest.java
index 62190fb0c69..6547d7c881e 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/run/DruidHookTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/run/DruidHookTest.java
@@ -21,7 +21,7 @@ package org.apache.druid.sql.calcite.run;
 
 import nl.jqno.equalsverifier.EqualsVerifier;
 import org.apache.druid.sql.hook.DruidHook;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 public class DruidHookTest
 {
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/run/SqlResultsTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/run/SqlResultsTest.java
index 027e9022124..64d3b1ca4c4 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/run/SqlResultsTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/run/SqlResultsTest.java
@@ -28,13 +28,10 @@ import org.apache.druid.error.DruidException;
 import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.segment.TestHelper;
 import org.apache.druid.testing.InitializedNullHandlingTest;
-import org.hamcrest.CoreMatchers;
-import org.hamcrest.MatcherAssert;
 import org.joda.time.DateTimeZone;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.internal.matchers.ThrowableMessageMatcher;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import java.util.Arrays;
 import java.util.Collections;
@@ -46,7 +43,7 @@ public class SqlResultsTest extends InitializedNullHandlingTest
 
   private ObjectMapper jsonMapper;
 
-  @Before
+  @BeforeEach
   public void setUp()
   {
     jsonMapper = TestHelper.JSON_MAPPER;
@@ -227,10 +224,10 @@ public class SqlResultsTest extends InitializedNullHandlingTest
   {
     try {
       assertCoerce("", new byte[1], SqlTypeName.BIGINT);
-      Assert.fail("Should throw an exception");
+      Assertions.fail("Should throw an exception");
     }
     catch (Exception e) {
-      Assert.assertEquals("Cannot coerce field [fieldName] from type [Byte Array] to type [BIGINT]", e.getMessage());
+      Assertions.assertEquals("Cannot coerce field [fieldName] from type [Byte Array] to type [BIGINT]", e.getMessage());
     }
   }
 
@@ -243,7 +240,7 @@ public class SqlResultsTest extends InitializedNullHandlingTest
   @Test
   public void testMayNotCoerceList()
   {
-    Assert.assertEquals("hello", SqlResults.coerceArrayToList("hello", false));
+    Assertions.assertEquals("hello", SqlResults.coerceArrayToList("hello", false));
   }
 
   @Test
@@ -254,27 +251,27 @@ public class SqlResultsTest extends InitializedNullHandlingTest
 
   private void assertCoerce(Object expected, Object toCoerce, SqlTypeName typeName)
   {
-    Assert.assertEquals(
-        StringUtils.format("Coerce [%s] to [%s]", toCoerce, typeName),
+    Assertions.assertEquals(
         expected,
-        SqlResults.coerce(jsonMapper, DEFAULT_CONTEXT, toCoerce, typeName, "fieldName")
+        SqlResults.coerce(jsonMapper, DEFAULT_CONTEXT, toCoerce, typeName, "fieldName"),
+        StringUtils.format("Coerce [%s] to [%s]", toCoerce, typeName)
     );
   }
 
   private void assertCannotCoerce(Object toCoerce, SqlTypeName typeName)
   {
-    final DruidException e = Assert.assertThrows(
-        StringUtils.format("Coerce [%s] to [%s]", toCoerce, typeName),
+    final DruidException e = Assertions.assertThrows(
         DruidException.class,
-        () -> SqlResults.coerce(jsonMapper, DEFAULT_CONTEXT, toCoerce, typeName, "")
+        () -> SqlResults.coerce(jsonMapper, DEFAULT_CONTEXT, toCoerce, typeName, ""),
+        StringUtils.format("Coerce [%s] to [%s]", toCoerce, typeName)
     );
 
-    MatcherAssert.assertThat(e, ThrowableMessageMatcher.hasMessage(CoreMatchers.containsString("Cannot coerce")));
+    Assertions.assertTrue(e.getMessage().contains("Cannot coerce"));
   }
 
   private void assertCoerceArrayToList(Object expected, Object toCoerce)
   {
     Object coerced = SqlResults.coerce(jsonMapper, DEFAULT_CONTEXT, toCoerce, SqlTypeName.ARRAY, "");
-    Assert.assertEquals(expected, coerced);
+    Assertions.assertEquals(expected, coerced);
   }
 }
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java b/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java
index 487c50570f3..ce56ed4155a 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java
@@ -126,6 +126,7 @@ import org.apache.druid.timeline.DataSegment;
 import org.apache.druid.utils.JvmUtils;
 
 import javax.inject.Named;
+
 import java.io.Closeable;
 import java.io.File;
 import java.io.IOException;
diff --git a/sql/src/test/java/org/apache/druid/sql/destination/ExportDestinationTest.java b/sql/src/test/java/org/apache/druid/sql/destination/ExportDestinationTest.java
index a06de536a2f..1903337108b 100644
--- a/sql/src/test/java/org/apache/druid/sql/destination/ExportDestinationTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/destination/ExportDestinationTest.java
@@ -27,8 +27,8 @@ import org.apache.druid.jackson.DefaultObjectMapper;
 import org.apache.druid.storage.StorageConfig;
 import org.apache.druid.storage.StorageConnectorModule;
 import org.apache.druid.storage.local.LocalFileExportStorageProvider;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
 
@@ -61,6 +61,6 @@ public class ExportDestinationTest
     byte[] bytes = objectMapper.writeValueAsBytes(exportDestination);
 
     ExportDestination deserialized = objectMapper.readValue(bytes, ExportDestination.class);
-    Assert.assertEquals(exportDestination, deserialized);
+    Assertions.assertEquals(exportDestination, deserialized);
   }
 }
diff --git a/sql/src/test/java/org/apache/druid/sql/destination/TableDestinationTest.java b/sql/src/test/java/org/apache/druid/sql/destination/TableDestinationTest.java
index 7af4ad2eb4d..0f76cfb9f1e 100644
--- a/sql/src/test/java/org/apache/druid/sql/destination/TableDestinationTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/destination/TableDestinationTest.java
@@ -21,8 +21,8 @@ package org.apache.druid.sql.destination;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.apache.druid.jackson.DefaultObjectMapper;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
 
@@ -37,6 +37,6 @@ public class TableDestinationTest
     byte[] bytes = objectMapper.writeValueAsBytes(tableDestination);
 
     TableDestination deserialized = objectMapper.readValue(bytes, TableDestination.class);
-    Assert.assertEquals(tableDestination, deserialized);
+    Assertions.assertEquals(tableDestination, deserialized);
   }
 }
diff --git a/sql/src/test/java/org/apache/druid/sql/guice/SqlModuleTest.java b/sql/src/test/java/org/apache/druid/sql/guice/SqlModuleTest.java
index e04032a6637..b1154ebb977 100644
--- a/sql/src/test/java/org/apache/druid/sql/guice/SqlModuleTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/guice/SqlModuleTest.java
@@ -74,19 +74,20 @@ import org.apache.druid.sql.calcite.view.NoopViewManager;
 import org.apache.druid.sql.calcite.view.ViewManager;
 import org.apache.druid.sql.http.SqlResourceTest;
 import org.easymock.EasyMock;
-import org.easymock.EasyMockRunner;
+import org.easymock.EasyMockExtension;
 import org.easymock.Mock;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 
 import javax.validation.Validation;
 import javax.validation.Validator;
+
 import java.util.Map;
 import java.util.Properties;
 
-@RunWith(EasyMockRunner.class)
+@ExtendWith(EasyMockExtension.class)
 public class SqlModuleTest
 {
   @Mock
@@ -130,7 +131,7 @@ public class SqlModuleTest
 
   private Injector injector;
 
-  @Before
+  @BeforeEach
   public void setUp()
   {
     EasyMock.replay(
@@ -160,8 +161,8 @@ public class SqlModuleTest
     injector = makeInjectorWithProperties(props);
 
     ViewManager viewManager = injector.getInstance(Key.get(ViewManager.class));
-    Assert.assertNotNull(viewManager);
-    Assert.assertTrue(viewManager instanceof NoopViewManager);
+    Assertions.assertNotNull(viewManager);
+    Assertions.assertTrue(viewManager instanceof NoopViewManager);
   }
 
   @Test
@@ -176,8 +177,8 @@ public class SqlModuleTest
     injector = makeInjectorWithProperties(props);
 
     ViewManager viewManager = injector.getInstance(Key.get(ViewManager.class));
-    Assert.assertNotNull(viewManager);
-    Assert.assertTrue(viewManager instanceof BindTestViewManager);
+    Assertions.assertNotNull(viewManager);
+    Assertions.assertTrue(viewManager instanceof BindTestViewManager);
   }
 
   private Injector makeInjectorWithProperties(final Properties props)
diff --git a/sql/src/test/java/org/apache/druid/sql/http/ResultFormatTest.java b/sql/src/test/java/org/apache/druid/sql/http/ResultFormatTest.java
index 37ee6de032a..a270b176373 100644
--- a/sql/src/test/java/org/apache/druid/sql/http/ResultFormatTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/http/ResultFormatTest.java
@@ -23,7 +23,7 @@ import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.apache.druid.jackson.DefaultObjectMapper;
 import org.apache.druid.java.util.common.StringUtils;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
@@ -39,17 +39,17 @@ public class ResultFormatTest
   public void testSerde(ResultFormat target) throws JsonProcessingException
   {
     final String json = jsonMapper.writeValueAsString(target);
-    Assert.assertEquals(StringUtils.format("\"%s\"", target.toString()), json);
-    Assert.assertEquals(target, jsonMapper.readValue(json, ResultFormat.class));
+    Assertions.assertEquals(StringUtils.format("\"%s\"", target.toString()), json);
+    Assertions.assertEquals(target, jsonMapper.readValue(json, ResultFormat.class));
   }
 
   @Test
   public void testDeserializeWithDifferentCase() throws JsonProcessingException
   {
-    Assert.assertEquals(ResultFormat.OBJECTLINES, jsonMapper.readValue("\"OBJECTLINES\"", ResultFormat.class));
-    Assert.assertEquals(ResultFormat.OBJECTLINES, jsonMapper.readValue("\"objectLines\"", ResultFormat.class));
-    Assert.assertEquals(ResultFormat.OBJECTLINES, jsonMapper.readValue("\"objectlines\"", ResultFormat.class));
-    Assert.assertEquals(ResultFormat.OBJECTLINES, jsonMapper.readValue("\"oBjEcTlInEs\"", ResultFormat.class));
+    Assertions.assertEquals(ResultFormat.OBJECTLINES, jsonMapper.readValue("\"OBJECTLINES\"", ResultFormat.class));
+    Assertions.assertEquals(ResultFormat.OBJECTLINES, jsonMapper.readValue("\"objectLines\"", ResultFormat.class));
+    Assertions.assertEquals(ResultFormat.OBJECTLINES, jsonMapper.readValue("\"objectlines\"", ResultFormat.class));
+    Assertions.assertEquals(ResultFormat.OBJECTLINES, jsonMapper.readValue("\"oBjEcTlInEs\"", ResultFormat.class));
   }
 
   public static Object[] provideResultFormats()
diff --git a/sql/src/test/java/org/apache/druid/sql/http/SqlHttpModuleTest.java b/sql/src/test/java/org/apache/druid/sql/http/SqlHttpModuleTest.java
index 87a501f00a8..67d6033a241 100644
--- a/sql/src/test/java/org/apache/druid/sql/http/SqlHttpModuleTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/http/SqlHttpModuleTest.java
@@ -39,17 +39,17 @@ import org.apache.druid.server.security.AuthorizerMapper;
 import org.apache.druid.sql.SqlStatementFactory;
 import org.apache.druid.sql.calcite.run.NativeSqlEngine;
 import org.easymock.EasyMock;
-import org.easymock.EasyMockRunner;
+import org.easymock.EasyMockExtension;
 import org.easymock.Mock;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 
 import java.util.Collections;
 import java.util.Set;
 
-@RunWith(EasyMockRunner.class)
+@ExtendWith(EasyMockExtension.class)
 public class SqlHttpModuleTest
 {
   @Mock
@@ -58,7 +58,7 @@ public class SqlHttpModuleTest
   private SqlHttpModule target;
   private Injector injector;
 
-  @Before
+  @BeforeEach
   public void setUp()
   {
     target = new SqlHttpModule();
@@ -85,9 +85,9 @@ public class SqlHttpModuleTest
   public void testSqlResourceIsInjectedAndSingleton()
   {
     SqlResource sqlResource = injector.getInstance(SqlResource.class);
-    Assert.assertNotNull(sqlResource);
+    Assertions.assertNotNull(sqlResource);
     SqlResource other = injector.getInstance(SqlResource.class);
-    Assert.assertSame(other, sqlResource);
+    Assertions.assertSame(other, sqlResource);
   }
 
   @Test
@@ -95,7 +95,7 @@ public class SqlHttpModuleTest
   {
     Set<Class<?>> jerseyResourceClasses =
         injector.getInstance(Key.get(new TypeLiteral<>() {}, JSR311Resource.class));
-    Assert.assertEquals(1, jerseyResourceClasses.size());
-    Assert.assertEquals(SqlResource.class, jerseyResourceClasses.iterator().next());
+    Assertions.assertEquals(1, jerseyResourceClasses.size());
+    Assertions.assertEquals(SqlResource.class, jerseyResourceClasses.iterator().next());
   }
 }
diff --git a/sql/src/test/java/org/apache/druid/sql/http/SqlQueryTest.java b/sql/src/test/java/org/apache/druid/sql/http/SqlQueryTest.java
index 90aac37aa45..52d16d9787e 100644
--- a/sql/src/test/java/org/apache/druid/sql/http/SqlQueryTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/http/SqlQueryTest.java
@@ -23,11 +23,12 @@ import com.fasterxml.jackson.databind.ObjectMapper;
 import org.apache.druid.jackson.DefaultObjectMapper;
 import org.apache.druid.server.initialization.jetty.HttpException;
 import org.easymock.EasyMock;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.ws.rs.core.Response;
+
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
@@ -45,7 +46,7 @@ public class SqlQueryTest
 
     SqlQuery result = SqlQuery.from(request, objectMapper);
 
-    Assert.assertEquals("SELECT 1", result.getQuery());
+    Assertions.assertEquals("SELECT 1", result.getQuery());
   }
 
   @Test
@@ -56,7 +57,7 @@ public class SqlQueryTest
 
     SqlQuery result = SqlQuery.from(request, objectMapper);
 
-    Assert.assertEquals("SELECT 2", result.getQuery());
+    Assertions.assertEquals("SELECT 2", result.getQuery());
   }
 
   @Test
@@ -67,7 +68,7 @@ public class SqlQueryTest
 
     SqlQuery result = SqlQuery.from(request, objectMapper);
 
-    Assert.assertEquals("SELECT 3", result.getQuery());
+    Assertions.assertEquals("SELECT 3", result.getQuery());
   }
 
   @Test
@@ -78,7 +79,7 @@ public class SqlQueryTest
 
     SqlQuery result = SqlQuery.from(request, objectMapper);
 
-    Assert.assertEquals("SELECT 4", result.getQuery());
+    Assertions.assertEquals("SELECT 4", result.getQuery());
   }
 
   @Test
@@ -89,7 +90,7 @@ public class SqlQueryTest
 
     SqlQuery result = SqlQuery.from(request, objectMapper);
 
-    Assert.assertEquals("SELECT 5", result.getQuery());
+    Assertions.assertEquals("SELECT 5", result.getQuery());
   }
 
   @Test
@@ -100,7 +101,7 @@ public class SqlQueryTest
 
     SqlQuery result = SqlQuery.from(request, objectMapper);
 
-    Assert.assertEquals("SELECT 6", result.getQuery());
+    Assertions.assertEquals("SELECT 6", result.getQuery());
   }
 
   @Test
@@ -111,7 +112,7 @@ public class SqlQueryTest
 
     SqlQuery result = SqlQuery.from(request, objectMapper);
 
-    Assert.assertEquals("SELECT 7", result.getQuery());
+    Assertions.assertEquals("SELECT 7", result.getQuery());
   }
 
   @Test
@@ -120,13 +121,13 @@ public class SqlQueryTest
     String content = "SELECT 8";
     HttpServletRequest request = createMockRequest(null, content);
 
-    HttpException exception = Assert.assertThrows(
+    HttpException exception = Assertions.assertThrows(
         HttpException.class,
         () -> SqlQuery.from(request, objectMapper)
     );
 
-    Assert.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
-    Assert.assertEquals("Missing Content-Type header", exception.getMessage());
+    Assertions.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
+    Assertions.assertEquals("Missing Content-Type header", exception.getMessage());
   }
 
   @Test
@@ -135,14 +136,14 @@ public class SqlQueryTest
     String xmlQuery = "<query>SELECT 9</query>";
     HttpServletRequest request = createMockRequest("application/xml", xmlQuery);
 
-    HttpException exception = Assert.assertThrows(
+    HttpException exception = Assertions.assertThrows(
         HttpException.class,
         () -> SqlQuery.from(request, objectMapper)
     );
 
-    Assert.assertEquals(Response.Status.UNSUPPORTED_MEDIA_TYPE, exception.getStatusCode());
-    Assert.assertTrue(exception.getMessage().contains("Unsupported Content-Type"));
-    Assert.assertTrue(exception.getMessage().contains("application/xml"));
+    Assertions.assertEquals(Response.Status.UNSUPPORTED_MEDIA_TYPE, exception.getStatusCode());
+    Assertions.assertTrue(exception.getMessage().contains("Unsupported Content-Type"));
+    Assertions.assertTrue(exception.getMessage().contains("application/xml"));
   }
 
   @Test
@@ -151,14 +152,14 @@ public class SqlQueryTest
     String xmlQuery = "<query>SELECT 10</query>";
     HttpServletRequest request = createMockRequest("application/xml; charset=UTF-8", xmlQuery);
 
-    HttpException exception = Assert.assertThrows(
+    HttpException exception = Assertions.assertThrows(
         HttpException.class,
         () -> SqlQuery.from(request, objectMapper)
     );
 
-    Assert.assertEquals(Response.Status.UNSUPPORTED_MEDIA_TYPE, exception.getStatusCode());
-    Assert.assertTrue(exception.getMessage().contains("Unsupported Content-Type"));
-    Assert.assertTrue(exception.getMessage().contains("application/xml"));
+    Assertions.assertEquals(Response.Status.UNSUPPORTED_MEDIA_TYPE, exception.getStatusCode());
+    Assertions.assertTrue(exception.getMessage().contains("Unsupported Content-Type"));
+    Assertions.assertTrue(exception.getMessage().contains("application/xml"));
   }
 
   @Test
@@ -167,13 +168,13 @@ public class SqlQueryTest
     String content = "SELECT 11";
     HttpServletRequest request = createMockRequest("invalid-content-type-format", content);
 
-    HttpException exception = Assert.assertThrows(
+    HttpException exception = Assertions.assertThrows(
         HttpException.class,
         () -> SqlQuery.from(request, objectMapper)
     );
 
-    Assert.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
-    Assert.assertTrue(exception.getMessage().contains("Invalid Content-Type header"));
+    Assertions.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
+    Assertions.assertTrue(exception.getMessage().contains("Invalid Content-Type header"));
   }
 
   @Test
@@ -182,13 +183,13 @@ public class SqlQueryTest
     String jsonQuery = "{}";
     HttpServletRequest request = createMockRequest("application/json", jsonQuery);
 
-    HttpException exception = Assert.assertThrows(
+    HttpException exception = Assertions.assertThrows(
         HttpException.class,
         () -> SqlQuery.from(request, objectMapper)
     );
 
-    Assert.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
-    Assert.assertTrue(exception.getMessage()
+    Assertions.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
+    Assertions.assertTrue(exception.getMessage()
                                .contains("Unable to read query from request: Cannot construct instance of "));
   }
 
@@ -198,12 +199,12 @@ public class SqlQueryTest
     String jsonQuery = "{\"query\": null}";
     HttpServletRequest request = createMockRequest("application/json", jsonQuery);
 
-    HttpException exception = Assert.assertThrows(
+    HttpException exception = Assertions.assertThrows(
         HttpException.class,
         () -> SqlQuery.from(request, objectMapper)
     );
 
-    Assert.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
+    Assertions.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
   }
 
   @Test
@@ -212,13 +213,13 @@ public class SqlQueryTest
     String textQuery = "";
     HttpServletRequest request = createMockRequest("text/plain", textQuery);
 
-    HttpException exception = Assert.assertThrows(
+    HttpException exception = Assertions.assertThrows(
         HttpException.class,
         () -> SqlQuery.from(request, objectMapper)
     );
 
-    Assert.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
-    Assert.assertEquals("Empty query", exception.getMessage());
+    Assertions.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
+    Assertions.assertEquals("Empty query", exception.getMessage());
   }
 
   @Test
@@ -227,13 +228,13 @@ public class SqlQueryTest
     String textQuery = "   \n\t  ";
     HttpServletRequest request = createMockRequest("text/plain", textQuery);
 
-    HttpException exception = Assert.assertThrows(
+    HttpException exception = Assertions.assertThrows(
         HttpException.class,
         () -> SqlQuery.from(request, objectMapper)
     );
 
-    Assert.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
-    Assert.assertEquals("Empty query", exception.getMessage());
+    Assertions.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
+    Assertions.assertEquals("Empty query", exception.getMessage());
   }
 
   @Test
@@ -242,13 +243,13 @@ public class SqlQueryTest
     String formQuery = "";
     HttpServletRequest request = createMockRequest("application/x-www-form-urlencoded", formQuery);
 
-    HttpException exception = Assert.assertThrows(
+    HttpException exception = Assertions.assertThrows(
         HttpException.class,
         () -> SqlQuery.from(request, objectMapper)
     );
 
-    Assert.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
-    Assert.assertEquals("Empty query", exception.getMessage());
+    Assertions.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
+    Assertions.assertEquals("Empty query", exception.getMessage());
   }
 
 
@@ -258,13 +259,13 @@ public class SqlQueryTest
     String malformedJson = "{\"query\":\"SELECT 12\""; // Missing closing brace
     HttpServletRequest request = createMockRequest("application/json", malformedJson);
 
-    HttpException exception = Assert.assertThrows(
+    HttpException exception = Assertions.assertThrows(
         HttpException.class,
         () -> SqlQuery.from(request, objectMapper)
     );
 
-    Assert.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
-    Assert.assertTrue(exception.getMessage().contains("Malformed SQL query wrapped in JSON: Unexpected end-of-input:"));
+    Assertions.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
+    Assertions.assertTrue(exception.getMessage().contains("Malformed SQL query wrapped in JSON: Unexpected end-of-input:"));
   }
 
   @Test
@@ -275,16 +276,16 @@ public class SqlQueryTest
 
     HttpServletRequest request1 = createMockRequest("APPLICATION/JSON", jsonQuery);
     SqlQuery result1 = SqlQuery.from(request1, objectMapper);
-    Assert.assertEquals("SELECT 13", result1.getQuery());
+    Assertions.assertEquals("SELECT 13", result1.getQuery());
 
     HttpServletRequest request2 = createMockRequest("Application/Json; Charset=UTF-8", jsonQuery);
     SqlQuery result2 = SqlQuery.from(request2, objectMapper);
-    Assert.assertEquals("SELECT 13", result2.getQuery());
+    Assertions.assertEquals("SELECT 13", result2.getQuery());
 
     String textQuery = "SELECT 14";
     HttpServletRequest request3 = createMockRequest("TEXT/PLAIN", textQuery);
     SqlQuery result3 = SqlQuery.from(request3, objectMapper);
-    Assert.assertEquals("SELECT 14", result3.getQuery());
+    Assertions.assertEquals("SELECT 14", result3.getQuery());
   }
 
   @Test
@@ -295,9 +296,9 @@ public class SqlQueryTest
 
     SqlQuery result = SqlQuery.from(request, objectMapper);
 
-    Assert.assertEquals("SELECT COUNT(*) FROM table WHERE col > 100", result.getQuery());
-    Assert.assertTrue(result.includeHeader());
-    Assert.assertNotNull(result.getContext());
+    Assertions.assertEquals("SELECT COUNT(*) FROM table WHERE col > 100", result.getQuery());
+    Assertions.assertTrue(result.includeHeader());
+    Assertions.assertNotNull(result.getContext());
   }
 
 
diff --git a/sql/src/test/java/org/apache/druid/sql/http/SqlResourceTest.java b/sql/src/test/java/org/apache/druid/sql/http/SqlResourceTest.java
index 6fb974a527c..3fa5243fc8b 100644
--- a/sql/src/test/java/org/apache/druid/sql/http/SqlResourceTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/http/SqlResourceTest.java
@@ -105,10 +105,9 @@ import org.apache.druid.sql.calcite.schema.DruidSchemaCatalog;
 import org.apache.druid.sql.calcite.util.CalciteTestBase;
 import org.apache.druid.sql.calcite.util.CalciteTests;
 import org.apache.druid.sql.hook.DruidHookDispatcher;
-import org.hamcrest.CoreMatchers;
-import org.junit.Assert;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -121,6 +120,7 @@ import javax.ws.rs.core.HttpHeaders;
 import javax.ws.rs.core.Response;
 import javax.ws.rs.core.Response.Status;
 import javax.ws.rs.core.StreamingOutput;
+
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.IOException;
@@ -357,12 +357,12 @@ public class SqlResourceTest extends CalciteTestBase
   @Test
   public void testUnauthorized()
   {
-    ForbiddenException e = Assert.assertThrows(ForbiddenException.class, () -> {
+    ForbiddenException e = Assertions.assertThrows(ForbiddenException.class, () -> {
       postForAsyncResponse(createSimpleQueryWithId("id", "select count(*) from forbiddenDatasource"), request());
     });
-    Assert.assertEquals("Unauthorized", e.getMessage());
-    Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
-    Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+    Assertions.assertEquals("Unauthorized", e.getMessage());
+    Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
+    Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
   }
 
   @Test
@@ -373,21 +373,21 @@ public class SqlResourceTest extends CalciteTestBase
         "id",
         "select count(*) as cnt from restrictedDatasource_m1_is_6"
     )).rhs;
-    Assert.assertEquals(ImmutableList.of(ImmutableMap.of("cnt", 6)), resultAsSuperUser);
+    Assertions.assertEquals(ImmutableList.of(ImmutableMap.of("cnt", 6)), resultAsSuperUser);
 
     checkSqlRequestLog(true, CalciteTests.TEST_SUPERUSER_NAME);
     testRequestLogger.clear();
-    Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+    Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
 
     req = makeRegularUserReq();
     final List<Map<String, Object>> resultAsRegularUser = doPost(createSimpleQueryWithId(
         "id",
         "select count(*) as cnt from restrictedDatasource_m1_is_6"
     )).rhs;
-    Assert.assertEquals(ImmutableList.of(ImmutableMap.of("cnt", 1)), resultAsRegularUser);
+    Assertions.assertEquals(ImmutableList.of(ImmutableMap.of("cnt", 1)), resultAsRegularUser);
     checkSqlRequestLog(true);
     testRequestLogger.clear();
-    Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+    Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
   }
 
   @Test
@@ -397,16 +397,16 @@ public class SqlResourceTest extends CalciteTestBase
         createSimpleQueryWithId("id", "SELECT COUNT(*) AS cnt, 'foo' AS TheFoo FROM druid.foo")
     ).rhs;
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             ImmutableMap.of("cnt", 6, "TheFoo", "foo")
         ),
         rows
     );
     checkSqlRequestLog(true);
-    Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+    Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
     stubServiceEmitter.verifyEmitted("sqlQuery/time", 1);
-    Assert.assertEquals(200, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
+    Assertions.assertEquals(200, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
   }
 
   @Test
@@ -414,7 +414,7 @@ public class SqlResourceTest extends CalciteTestBase
   {
     Response response = resource.getSupportedEngines(req);
     Set<EngineInfo> supportedEngines = ((SupportedEnginesResponse) response.getEntity()).getEngines();
-    Assert.assertTrue(supportedEngines.contains(new EngineInfo(NativeSqlEngine.NAME)));
+    Assertions.assertTrue(supportedEngines.contains(new EngineInfo(NativeSqlEngine.NAME)));
   }
 
   @Test
@@ -462,18 +462,18 @@ public class SqlResourceTest extends CalciteTestBase
                                                           })
                                                           .collect(Collectors.toList());
 
-    Assert.assertEquals(expectedMissingHeaders, observedMissingHeaders);
+    Assertions.assertEquals(expectedMissingHeaders, observedMissingHeaders);
 
     Object results = JSON_MAPPER.readValue(response.baos.toByteArray(), Object.class);
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             ImmutableMap.of("cnt", 6, "TheFoo", "foo")
         ),
         results
     );
     checkSqlRequestLog(true);
-    Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+    Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
   }
 
   @Test
@@ -483,18 +483,18 @@ public class SqlResourceTest extends CalciteTestBase
         createSimpleQueryWithId("id", "SELECT COUNT(*) AS cnt, 'foo' AS TheFoo FROM druid.foo")
     ).rhs;
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             ImmutableMap.of("cnt", 6, "TheFoo", "foo")
         ),
         rows
     );
     checkSqlRequestLog(true);
-    Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+    Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
     stubServiceEmitter.verifyEmitted("sqlQuery/time", 1);
     stubServiceEmitter.verifyValue("sqlQuery/bytes", 27L);
     stubServiceEmitter.verifyEmitted("sqlQuery/planningTimeMs", 1);
-    Assert.assertEquals(200, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
+    Assertions.assertEquals(200, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
   }
 
 
@@ -508,14 +508,14 @@ public class SqlResourceTest extends CalciteTestBase
         )
     ).rhs;
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             ImmutableMap.of("cnt", 1)
         ),
         rows
     );
     checkSqlRequestLog(true);
-    Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+    Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
   }
 
   @Test
@@ -533,7 +533,7 @@ public class SqlResourceTest extends CalciteTestBase
         )
     ).rhs;
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             ImmutableMap.of("__time", "2000-01-01T00:00:00.000Z", "t2", "2000-01-01T00:00:00.000Z")
         ),
@@ -556,7 +556,7 @@ public class SqlResourceTest extends CalciteTestBase
         )
     ).rhs;
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             ImmutableMap.of("__time", "2000-01-01T00:00:00.000Z", "t2", "2000-01-01T00:00:00.000Z")
         ),
@@ -579,7 +579,7 @@ public class SqlResourceTest extends CalciteTestBase
         )
     ).rhs;
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             ImmutableMap.of("__time", "1999-12-31T16:00:00.000-08:00", "t2", "1999-12-31T00:00:00.000-08:00")
         ),
@@ -622,7 +622,7 @@ public class SqlResourceTest extends CalciteTestBase
         )
     ).rhs;
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             ImmutableMap.of("__time", "1999-12-31T16:00:00.000-08:00", "t2", "1999-12-31T00:00:00.000-08:00")
         ),
@@ -645,7 +645,7 @@ public class SqlResourceTest extends CalciteTestBase
         )
     ).rhs;
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             Maps.transformValues(
                 ImmutableMap.of("t1", "2001-01-03T00:00:00.000Z", "t2", ""),
@@ -671,7 +671,7 @@ public class SqlResourceTest extends CalciteTestBase
         )
     ).rhs;
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             ImmutableMap.of("x", "a", "y", "a")
         ),
@@ -694,7 +694,7 @@ public class SqlResourceTest extends CalciteTestBase
         )
     ).rhs;
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             // x and y both should be null instead of empty string
             Maps.transformValues(ImmutableMap.of("x", "", "y", ""), (val) -> null),
@@ -746,7 +746,7 @@ public class SqlResourceTest extends CalciteTestBase
         )
     ).rhs;
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             ImmutableMap.of("Age", "18-19", "Women", 0.040737148399612025, "Men", 0.1052376333656644),
             ImmutableMap.of("Age", "20-29", "Women", 0.1556741028128031, "Men", 0.3976721629485936),
@@ -797,7 +797,7 @@ public class SqlResourceTest extends CalciteTestBase
         )
     ).rhs;
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             ImmutableMap.of("Age", "18-19", "Women", 0.040737148399612025, "Men", 0.1052376333656644),
             ImmutableMap.of("Age", "20-29", "Women", 0.1556741028128031, "Men", 0.3976721629485936),
@@ -814,7 +814,7 @@ public class SqlResourceTest extends CalciteTestBase
   {
     final String query = "SELECT *, CASE dim2 WHEN '' THEN dim2 END FROM foo LIMIT 2";
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             Arrays.asList(
                 "2000-01-01T00:00:00.000Z",
@@ -858,8 +858,8 @@ public class SqlResourceTest extends CalciteTestBase
         doPostRaw(new SqlQuery(query, ResultFormat.ARRAY, false, false, false, null, null), req);
 
     // Truncated response: missing final ]
-    Assert.assertNull(response.lhs);
-    Assert.assertEquals("[[1],[1]", response.rhs);
+    Assertions.assertNull(response.lhs);
+    Assertions.assertEquals("[[1],[1]", response.rhs);
   }
 
   @Test
@@ -872,8 +872,8 @@ public class SqlResourceTest extends CalciteTestBase
         doPostRaw(new SqlQuery(query, ResultFormat.OBJECT, false, false, false, null, null), req);
 
     // Truncated response: missing final ]
-    Assert.assertNull(response.lhs);
-    Assert.assertEquals("[{\"cnt\":1},{\"cnt\":1}", response.rhs);
+    Assertions.assertNull(response.lhs);
+    Assertions.assertEquals("[{\"cnt\":1},{\"cnt\":1}", response.rhs);
   }
 
   @Test
@@ -886,8 +886,8 @@ public class SqlResourceTest extends CalciteTestBase
         doPostRaw(new SqlQuery(query, ResultFormat.ARRAYLINES, false, false, false, null, null), req);
 
     // Truncated response: missing final LFLF
-    Assert.assertNull(response.lhs);
-    Assert.assertEquals("[1]\n[1]", response.rhs);
+    Assertions.assertNull(response.lhs);
+    Assertions.assertEquals("[1]\n[1]", response.rhs);
   }
 
   @Test
@@ -900,8 +900,8 @@ public class SqlResourceTest extends CalciteTestBase
         doPostRaw(new SqlQuery(query, ResultFormat.OBJECTLINES, false, false, false, null, null), req);
 
     // Truncated response: missing final LFLF
-    Assert.assertNull(response.lhs);
-    Assert.assertEquals("{\"cnt\":1}\n{\"cnt\":1}", response.rhs);
+    Assertions.assertNull(response.lhs);
+    Assertions.assertEquals("{\"cnt\":1}\n{\"cnt\":1}", response.rhs);
   }
 
   @Test
@@ -914,8 +914,8 @@ public class SqlResourceTest extends CalciteTestBase
         doPostRaw(new SqlQuery(query, ResultFormat.CSV, false, false, false, null, null), req);
 
     // Truncated response: missing final LFLF
-    Assert.assertNull(response.lhs);
-    Assert.assertEquals("1\n1\n", response.rhs);
+    Assertions.assertNull(response.lhs);
+    Assertions.assertEquals("1\n1\n", response.rhs);
   }
 
   @Test
@@ -934,9 +934,9 @@ public class SqlResourceTest extends CalciteTestBase
         req.mimic()
     );
 
-    Assert.assertEquals(200, response.getStatus());
-    Assert.assertEquals("yes", response.getHeader("X-Druid-SQL-Header-Included"));
-    Assert.assertEquals(
+    Assertions.assertEquals(200, response.getStatus());
+    Assertions.assertEquals("yes", response.getHeader("X-Druid-SQL-Header-Included"));
+    Assertions.assertEquals(
         ImmutableList.builder()
                      .add(EXPECTED_COLUMNS_FOR_RESULT_FORMAT_TESTS)
                      .add(EXPECTED_TYPES_FOR_RESULT_FORMAT_TESTS)
@@ -951,9 +951,9 @@ public class SqlResourceTest extends CalciteTestBase
         req.mimic()
     );
 
-    Assert.assertEquals(200, responseNoSqlTypesHeader.getStatus());
-    Assert.assertEquals("yes", responseNoSqlTypesHeader.getHeader("X-Druid-SQL-Header-Included"));
-    Assert.assertEquals(
+    Assertions.assertEquals(200, responseNoSqlTypesHeader.getStatus());
+    Assertions.assertEquals("yes", responseNoSqlTypesHeader.getHeader("X-Druid-SQL-Header-Included"));
+    Assertions.assertEquals(
         ImmutableList.builder()
                      .add(EXPECTED_COLUMNS_FOR_RESULT_FORMAT_TESTS)
                      .add(EXPECTED_TYPES_FOR_RESULT_FORMAT_TESTS)
@@ -967,9 +967,9 @@ public class SqlResourceTest extends CalciteTestBase
         req.mimic()
     );
 
-    Assert.assertEquals(200, responseNoTypesHeader.getStatus());
-    Assert.assertEquals("yes", responseNoTypesHeader.getHeader("X-Druid-SQL-Header-Included"));
-    Assert.assertEquals(
+    Assertions.assertEquals(200, responseNoTypesHeader.getStatus());
+    Assertions.assertEquals("yes", responseNoTypesHeader.getHeader("X-Druid-SQL-Header-Included"));
+    Assertions.assertEquals(
         ImmutableList.builder()
                      .add(EXPECTED_COLUMNS_FOR_RESULT_FORMAT_TESTS)
                      .add(EXPECTED_SQL_TYPES_FOR_RESULT_FORMAT_TESTS)
@@ -983,9 +983,9 @@ public class SqlResourceTest extends CalciteTestBase
         req.mimic()
     );
 
-    Assert.assertEquals(200, responseNoTypes.getStatus());
-    Assert.assertEquals("yes", responseNoTypes.getHeader("X-Druid-SQL-Header-Included"));
-    Assert.assertEquals(
+    Assertions.assertEquals(200, responseNoTypes.getStatus());
+    Assertions.assertEquals("yes", responseNoTypes.getHeader("X-Druid-SQL-Header-Included"));
+    Assertions.assertEquals(
         ImmutableList.builder()
                      .add(EXPECTED_COLUMNS_FOR_RESULT_FORMAT_TESTS)
                      .addAll(Arrays.asList(expectedQueryResults))
@@ -998,9 +998,9 @@ public class SqlResourceTest extends CalciteTestBase
         req.mimic()
     );
 
-    Assert.assertEquals(200, responseNoHeader.getStatus());
-    Assert.assertNull(responseNoHeader.getHeader("X-Druid-SQL-Header-Included"));
-    Assert.assertEquals(
+    Assertions.assertEquals(200, responseNoHeader.getStatus());
+    Assertions.assertNull(responseNoHeader.getHeader("X-Druid-SQL-Header-Included"));
+    Assertions.assertEquals(
         Arrays.asList(expectedQueryResults),
         JSON_MAPPER.readValue(responseNoHeader.baos.toByteArray(), Object.class)
     );
@@ -1018,10 +1018,10 @@ public class SqlResourceTest extends CalciteTestBase
         req
     );
 
-    Assert.assertEquals(200, response.getStatus());
-    Assert.assertEquals("yes", response.getHeader("X-Druid-SQL-Header-Included"));
+    Assertions.assertEquals(200, response.getStatus());
+    Assertions.assertEquals("yes", response.getHeader("X-Druid-SQL-Header-Included"));
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             Collections.singletonList("EXPR$0"),
             Collections.singletonList(null),
@@ -1044,12 +1044,12 @@ public class SqlResourceTest extends CalciteTestBase
     final Pair<ErrorResponse, String> pair = doPostRaw(
         new SqlQuery(query, ResultFormat.ARRAYLINES, false, false, false, null, null)
     );
-    Assert.assertNull(pair.lhs);
+    Assertions.assertNull(pair.lhs);
     final String response = pair.rhs;
     final List<String> lines = Splitter.on('\n').splitToList(response);
 
-    Assert.assertEquals(4, lines.size());
-    Assert.assertEquals(
+    Assertions.assertEquals(4, lines.size());
+    Assertions.assertEquals(
         Arrays.asList(
             "2000-01-01T00:00:00.000Z",
             "",
@@ -1063,7 +1063,7 @@ public class SqlResourceTest extends CalciteTestBase
         ),
         JSON_MAPPER.readValue(lines.get(0), List.class)
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         Arrays.asList(
             "2000-01-02T00:00:00.000Z",
             "10.1",
@@ -1077,8 +1077,8 @@ public class SqlResourceTest extends CalciteTestBase
         ),
         JSON_MAPPER.readValue(lines.get(1), List.class)
     );
-    Assert.assertEquals("", lines.get(2));
-    Assert.assertEquals("", lines.get(3));
+    Assertions.assertEquals("", lines.get(2));
+    Assertions.assertEquals("", lines.get(3));
   }
 
   @Test
@@ -1088,15 +1088,15 @@ public class SqlResourceTest extends CalciteTestBase
     final Pair<ErrorResponse, String> pair = doPostRaw(
         new SqlQuery(query, ResultFormat.ARRAYLINES, true, true, true, null, null)
     );
-    Assert.assertNull(pair.lhs);
+    Assertions.assertNull(pair.lhs);
     final String response = pair.rhs;
     final List<String> lines = Splitter.on('\n').splitToList(response);
 
-    Assert.assertEquals(7, lines.size());
-    Assert.assertEquals(EXPECTED_COLUMNS_FOR_RESULT_FORMAT_TESTS, JSON_MAPPER.readValue(lines.get(0), List.class));
-    Assert.assertEquals(EXPECTED_TYPES_FOR_RESULT_FORMAT_TESTS, JSON_MAPPER.readValue(lines.get(1), List.class));
-    Assert.assertEquals(EXPECTED_SQL_TYPES_FOR_RESULT_FORMAT_TESTS, JSON_MAPPER.readValue(lines.get(2), List.class));
-    Assert.assertEquals(
+    Assertions.assertEquals(7, lines.size());
+    Assertions.assertEquals(EXPECTED_COLUMNS_FOR_RESULT_FORMAT_TESTS, JSON_MAPPER.readValue(lines.get(0), List.class));
+    Assertions.assertEquals(EXPECTED_TYPES_FOR_RESULT_FORMAT_TESTS, JSON_MAPPER.readValue(lines.get(1), List.class));
+    Assertions.assertEquals(EXPECTED_SQL_TYPES_FOR_RESULT_FORMAT_TESTS, JSON_MAPPER.readValue(lines.get(2), List.class));
+    Assertions.assertEquals(
         Arrays.asList(
             "2000-01-01T00:00:00.000Z",
             "",
@@ -1110,7 +1110,7 @@ public class SqlResourceTest extends CalciteTestBase
         ),
         JSON_MAPPER.readValue(lines.get(3), List.class)
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         Arrays.asList(
             "2000-01-02T00:00:00.000Z",
             "10.1",
@@ -1124,8 +1124,8 @@ public class SqlResourceTest extends CalciteTestBase
         ),
         JSON_MAPPER.readValue(lines.get(4), List.class)
     );
-    Assert.assertEquals("", lines.get(5));
-    Assert.assertEquals("", lines.get(6));
+    Assertions.assertEquals("", lines.get(5));
+    Assertions.assertEquals("", lines.get(6));
   }
 
   @Test
@@ -1135,15 +1135,15 @@ public class SqlResourceTest extends CalciteTestBase
     final Pair<ErrorResponse, String> pair = doPostRaw(
         new SqlQuery(query, ResultFormat.ARRAYLINES, true, true, true, null, null)
     );
-    Assert.assertNull(pair.lhs);
+    Assertions.assertNull(pair.lhs);
     final String response = pair.rhs;
     final List<String> lines = Splitter.on('\n').splitToList(response);
 
-    Assert.assertEquals(6, lines.size());
-    Assert.assertEquals(Collections.singletonList("EXPR$0"), JSON_MAPPER.readValue(lines.get(0), List.class));
-    Assert.assertEquals(Collections.singletonList(null), JSON_MAPPER.readValue(lines.get(1), List.class));
-    Assert.assertEquals(Collections.singletonList("ROW"), JSON_MAPPER.readValue(lines.get(2), List.class));
-    Assert.assertEquals(
+    Assertions.assertEquals(6, lines.size());
+    Assertions.assertEquals(Collections.singletonList("EXPR$0"), JSON_MAPPER.readValue(lines.get(0), List.class));
+    Assertions.assertEquals(Collections.singletonList(null), JSON_MAPPER.readValue(lines.get(1), List.class));
+    Assertions.assertEquals(Collections.singletonList("ROW"), JSON_MAPPER.readValue(lines.get(2), List.class));
+    Assertions.assertEquals(
         Collections.singletonList(
             Arrays.asList(
                 1,
@@ -1152,8 +1152,8 @@ public class SqlResourceTest extends CalciteTestBase
         ),
         JSON_MAPPER.readValue(lines.get(3), List.class)
     );
-    Assert.assertEquals("", lines.get(4));
-    Assert.assertEquals("", lines.get(5));
+    Assertions.assertEquals("", lines.get(4));
+    Assertions.assertEquals("", lines.get(5));
   }
 
   @Test
@@ -1165,7 +1165,7 @@ public class SqlResourceTest extends CalciteTestBase
         (k, v) -> "EXPR$8".equals(k) || ("dim2".equals(k) && v.toString().isEmpty()) ? null : v
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             ImmutableMap
                 .<String, Object>builder()
@@ -1208,7 +1208,7 @@ public class SqlResourceTest extends CalciteTestBase
     final Pair<ErrorResponse, String> pair = doPostRaw(
         new SqlQuery(query, ResultFormat.OBJECTLINES, false, false, false, null, null)
     );
-    Assert.assertNull(pair.lhs);
+    Assertions.assertNull(pair.lhs);
     final String response = pair.rhs;
     final Function<Map<String, Object>, Map<String, Object>> transformer = m -> {
       return Maps.transformEntries(
@@ -1218,8 +1218,8 @@ public class SqlResourceTest extends CalciteTestBase
     };
     final List<String> lines = Splitter.on('\n').splitToList(response);
 
-    Assert.assertEquals(4, lines.size());
-    Assert.assertEquals(
+    Assertions.assertEquals(4, lines.size());
+    Assertions.assertEquals(
         transformer.apply(
             ImmutableMap
                 .<String, Object>builder()
@@ -1236,7 +1236,7 @@ public class SqlResourceTest extends CalciteTestBase
         ),
         JSON_MAPPER.readValue(lines.get(0), Object.class)
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         transformer.apply(
             ImmutableMap
                 .<String, Object>builder()
@@ -1253,8 +1253,8 @@ public class SqlResourceTest extends CalciteTestBase
         ),
         JSON_MAPPER.readValue(lines.get(1), Object.class)
     );
-    Assert.assertEquals("", lines.get(2));
-    Assert.assertEquals("", lines.get(3));
+    Assertions.assertEquals("", lines.get(2));
+    Assertions.assertEquals("", lines.get(3));
   }
 
   @Test
@@ -1263,7 +1263,7 @@ public class SqlResourceTest extends CalciteTestBase
     final String query = "SELECT *, CASE dim2 WHEN '' THEN dim2 END FROM foo LIMIT 2";
     final Pair<ErrorResponse, String> pair =
         doPostRaw(new SqlQuery(query, ResultFormat.OBJECTLINES, true, false, false, null, null));
-    Assert.assertNull(pair.lhs);
+    Assertions.assertNull(pair.lhs);
     final String response = pair.rhs;
     final Function<Map<String, Object>, Map<String, Object>> transformer = m -> Maps.transformEntries(
         m,
@@ -1276,9 +1276,9 @@ public class SqlResourceTest extends CalciteTestBase
       expectedHeader.put(column, null);
     }
 
-    Assert.assertEquals(5, lines.size());
-    Assert.assertEquals(expectedHeader, JSON_MAPPER.readValue(lines.get(0), Object.class));
-    Assert.assertEquals(
+    Assertions.assertEquals(5, lines.size());
+    Assertions.assertEquals(expectedHeader, JSON_MAPPER.readValue(lines.get(0), Object.class));
+    Assertions.assertEquals(
         transformer.apply(
             ImmutableMap
                 .<String, Object>builder()
@@ -1295,7 +1295,7 @@ public class SqlResourceTest extends CalciteTestBase
         ),
         JSON_MAPPER.readValue(lines.get(1), Object.class)
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         transformer.apply(
             ImmutableMap
                 .<String, Object>builder()
@@ -1312,8 +1312,8 @@ public class SqlResourceTest extends CalciteTestBase
         ),
         JSON_MAPPER.readValue(lines.get(2), Object.class)
     );
-    Assert.assertEquals("", lines.get(3));
-    Assert.assertEquals("", lines.get(4));
+    Assertions.assertEquals("", lines.get(3));
+    Assertions.assertEquals("", lines.get(4));
   }
 
   @Test
@@ -1322,7 +1322,7 @@ public class SqlResourceTest extends CalciteTestBase
     final String query = "SELECT *, CASE dim2 WHEN '' THEN dim2 END FROM foo LIMIT 2";
     final Pair<ErrorResponse, String> pair =
         doPostRaw(new SqlQuery(query, ResultFormat.OBJECTLINES, true, true, true, null, null));
-    Assert.assertNull(pair.lhs);
+    Assertions.assertNull(pair.lhs);
     final String response = pair.rhs;
     final Function<Map<String, Object>, Map<String, Object>> transformer = m -> Maps.transformEntries(
         m,
@@ -1341,9 +1341,9 @@ public class SqlResourceTest extends CalciteTestBase
       );
     }
 
-    Assert.assertEquals(5, lines.size());
-    Assert.assertEquals(expectedHeader, JSON_MAPPER.readValue(lines.get(0), Object.class));
-    Assert.assertEquals(
+    Assertions.assertEquals(5, lines.size());
+    Assertions.assertEquals(expectedHeader, JSON_MAPPER.readValue(lines.get(0), Object.class));
+    Assertions.assertEquals(
         transformer.apply(
             ImmutableMap
                 .<String, Object>builder()
@@ -1360,7 +1360,7 @@ public class SqlResourceTest extends CalciteTestBase
         ),
         JSON_MAPPER.readValue(lines.get(1), Object.class)
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         transformer.apply(
             ImmutableMap
                 .<String, Object>builder()
@@ -1377,8 +1377,8 @@ public class SqlResourceTest extends CalciteTestBase
         ),
         JSON_MAPPER.readValue(lines.get(2), Object.class)
     );
-    Assert.assertEquals("", lines.get(3));
-    Assert.assertEquals("", lines.get(4));
+    Assertions.assertEquals("", lines.get(3));
+    Assertions.assertEquals("", lines.get(4));
   }
 
   @Test
@@ -1387,7 +1387,7 @@ public class SqlResourceTest extends CalciteTestBase
     final String query = "SELECT (1, 2) FROM INFORMATION_SCHEMA.COLUMNS LIMIT 1";
     final Pair<ErrorResponse, String> pair =
         doPostRaw(new SqlQuery(query, ResultFormat.OBJECTLINES, true, true, true, null, null));
-    Assert.assertNull(pair.lhs);
+    Assertions.assertNull(pair.lhs);
     final String response = pair.rhs;
     final List<String> lines = Splitter.on('\n').splitToList(response);
 
@@ -1396,9 +1396,9 @@ public class SqlResourceTest extends CalciteTestBase
     typeMap.put(ObjectWriter.SQL_TYPE_HEADER_NAME, "ROW");
     final Map<String, Object> expectedHeader = ImmutableMap.of("EXPR$0", typeMap);
 
-    Assert.assertEquals(4, lines.size());
-    Assert.assertEquals(expectedHeader, JSON_MAPPER.readValue(lines.get(0), Object.class));
-    Assert.assertEquals(
+    Assertions.assertEquals(4, lines.size());
+    Assertions.assertEquals(expectedHeader, JSON_MAPPER.readValue(lines.get(0), Object.class));
+    Assertions.assertEquals(
         ImmutableMap
             .<String, Object>builder()
             .put("EXPR$0", Arrays.asList(1, 2))
@@ -1406,8 +1406,8 @@ public class SqlResourceTest extends CalciteTestBase
         JSON_MAPPER.readValue(lines.get(1), Object.class)
     );
 
-    Assert.assertEquals("", lines.get(2));
-    Assert.assertEquals("", lines.get(3));
+    Assertions.assertEquals("", lines.get(2));
+    Assertions.assertEquals("", lines.get(3));
   }
 
   @Test
@@ -1417,11 +1417,11 @@ public class SqlResourceTest extends CalciteTestBase
     final Pair<ErrorResponse, String> pair = doPostRaw(
         new SqlQuery(query, ResultFormat.CSV, false, false, false, null, null)
     );
-    Assert.assertNull(pair.lhs);
+    Assertions.assertNull(pair.lhs);
     final String response = pair.rhs;
     final List<String> lines = Splitter.on('\n').splitToList(response);
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             "2000-01-01T00:00:00.000Z,,a,\"[\"\"a\"\",\"\"b\"\"]\",1,1.0,1.0,\"\"\"AQAAAEAAAA==\"\"\",",
             "2000-01-02T00:00:00.000Z,10.1,,\"[\"\"b\"\",\"\"c\"\"]\",1,2.0,2.0,\"\"\"AQAAAQAAAAHNBA==\"\"\",",
@@ -1439,11 +1439,11 @@ public class SqlResourceTest extends CalciteTestBase
     final Pair<ErrorResponse, String> pair = doPostRaw(
         new SqlQuery(query, ResultFormat.CSV, true, true, true, null, null)
     );
-    Assert.assertNull(pair.lhs);
+    Assertions.assertNull(pair.lhs);
     final String response = pair.rhs;
     final List<String> lines = Splitter.on('\n').splitToList(response);
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             String.join(",", EXPECTED_COLUMNS_FOR_RESULT_FORMAT_TESTS),
             String.join(",", EXPECTED_TYPES_FOR_RESULT_FORMAT_TESTS),
@@ -1464,11 +1464,11 @@ public class SqlResourceTest extends CalciteTestBase
     final Pair<ErrorResponse, String> pair = doPostRaw(
         new SqlQuery(query, ResultFormat.CSV, true, true, true, null, null)
     );
-    Assert.assertNull(pair.lhs);
+    Assertions.assertNull(pair.lhs);
     final String response = pair.rhs;
     final List<String> lines = Splitter.on('\n').splitToList(response);
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             "EXPR$0",
             "",
@@ -1499,7 +1499,7 @@ public class SqlResourceTest extends CalciteTestBase
         )
     ).rhs;
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             ImmutableMap.<String, Object>of(
                 "PLAN",
@@ -1528,8 +1528,8 @@ public class SqlResourceTest extends CalciteTestBase
         errorResponse,
         "Incorrect syntax near the keyword 'FROM' at line 1, column 1"
     );
-    Assert.assertEquals(0, testRequestLogger.getSqlQueryLogs().size()); // Invalid queries are not logged
-    Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+    Assertions.assertEquals(0, testRequestLogger.getSqlQueryLogs().size()); // Invalid queries are not logged
+    Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
   }
 
   @Test
@@ -1545,9 +1545,9 @@ public class SqlResourceTest extends CalciteTestBase
         "Column 'dim4' not found in any table"
     );
     checkSqlRequestLog(false);
-    Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+    Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
     stubServiceEmitter.verifyEmitted("sqlQuery/time", 1);
-    Assert.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
+    Assertions.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
   }
 
   @Test
@@ -1557,7 +1557,7 @@ public class SqlResourceTest extends CalciteTestBase
     final SqlQuery unsupportedQuery = createSimpleQueryWithId("id", "SELECT dim1 FROM druid.foo ORDER BY dim1");
     ErrorResponse exception = postSyncForException(unsupportedQuery, Status.BAD_REQUEST.getStatusCode());
 
-    Assert.assertTrue((Boolean) req.getAttribute(AuthConfig.DRUID_AUTHORIZATION_CHECKED));
+    Assertions.assertTrue((Boolean) req.getAttribute(AuthConfig.DRUID_AUTHORIZATION_CHECKED));
 
     validateErrorResponse(
         exception,
@@ -1568,9 +1568,9 @@ public class SqlResourceTest extends CalciteTestBase
         + "[SQL query requires ordering a table by non-time column [[dim1]], which is not supported.]"
     );
     checkSqlRequestLog(false);
-    Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+    Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
     stubServiceEmitter.verifyEmitted("sqlQuery/time", 1);
-    Assert.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
+    Assertions.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
   }
 
   /**
@@ -1592,9 +1592,9 @@ public class SqlResourceTest extends CalciteTestBase
         "Aggregation [MAX] does not support type [STRING], column [v0]"
     );
     checkSqlRequestLog(false);
-    Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+    Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
     stubServiceEmitter.verifyEmitted("sqlQuery/time", 1);
-    Assert.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
+    Assertions.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
   }
 
   @Test
@@ -1618,7 +1618,7 @@ public class SqlResourceTest extends CalciteTestBase
         ResourceLimitExceededException.class.getName(),
         ""
     );
-    Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+    Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
   }
 
   private void failOnExecute(String errorMessage)
@@ -1647,7 +1647,7 @@ public class SqlResourceTest extends CalciteTestBase
     );
 
     validateInvalidSqlError(exception, "Incorrect syntax near the keyword 'TO'");
-    Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+    Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
   }
 
   @Test
@@ -1672,8 +1672,8 @@ public class SqlResourceTest extends CalciteTestBase
     // This is checked in the common method that returns the response, but checking it again just protects
     // from changes there breaking the checks, so doesn't hurt.
     assertStatusAndCommonHeaders(response, DruidException.Category.INVALID_INPUT.getExpectedStatus());
-    Assert.assertEquals(queryId, getHeader(response, QueryResource.QUERY_ID_RESPONSE_HEADER));
-    Assert.assertEquals(queryId, getHeader(response, SqlResource.SQL_QUERY_ID_RESPONSE_HEADER));
+    Assertions.assertEquals(queryId, getHeader(response, QueryResource.QUERY_ID_RESPONSE_HEADER));
+    Assertions.assertEquals(queryId, getHeader(response, SqlResource.SQL_QUERY_ID_RESPONSE_HEADER));
   }
 
   @Test
@@ -1694,8 +1694,8 @@ public class SqlResourceTest extends CalciteTestBase
     final Response response = resource.doPost(sqlQuery, req);
 
     // Query ID won't be set, but we can look for other aspects of the response that we expect.
-    Assert.assertEquals(DruidException.Category.INVALID_INPUT.getExpectedStatus(), response.getStatus());
-    Assert.assertEquals("application/json", getContentType(response));
+    Assertions.assertEquals(DruidException.Category.INVALID_INPUT.getExpectedStatus(), response.getStatus());
+    Assertions.assertEquals("application/json", getContentType(response));
   }
 
   @Test
@@ -1749,7 +1749,7 @@ public class SqlResourceTest extends CalciteTestBase
         "org.apache.druid.query.QueryUnsupportedException",
         "This will be supported in Druid 9999"
     );
-    Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+    Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
   }
 
   /**
@@ -1785,9 +1785,9 @@ public class SqlResourceTest extends CalciteTestBase
             .invalidSqlInput()
             .expectMessageIs("Calcite assertion violated: [not a literal: assertion_error()]")
     );
-    Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+    Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
     stubServiceEmitter.verifyEmitted("sqlQuery/time", 1);
-    Assert.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
+    Assertions.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
   }
 
   @Test
@@ -1864,8 +1864,8 @@ public class SqlResourceTest extends CalciteTestBase
         Response response = (Response) futures.get(i).get();
         assertStatusAndCommonHeaders(response, 429);
         QueryException interruped = deserializeResponse(response, QueryException.class);
-        Assert.assertEquals(QueryException.QUERY_CAPACITY_EXCEEDED_ERROR_CODE, interruped.getErrorCode());
-        Assert.assertEquals(
+        Assertions.assertEquals(QueryException.QUERY_CAPACITY_EXCEEDED_ERROR_CODE, interruped.getErrorCode());
+        Assertions.assertEquals(
             QueryCapacityExceededException.makeLaneErrorMessage(HiLoQueryLaningStrategy.LOW, 2),
             interruped.getMessage()
         );
@@ -1873,17 +1873,17 @@ public class SqlResourceTest extends CalciteTestBase
       } else {
         MockHttpServletResponse response = (MockHttpServletResponse) futures.get(i).get();
         assertStatusAndCommonHeaders(response, 200);
-        Assert.assertEquals(
+        Assertions.assertEquals(
             ImmutableList.of(ImmutableMap.of("cnt", 6, "TheFoo", "foo")),
             deserializeResponse(response, Object.class)
         );
         success++;
       }
     }
-    Assert.assertEquals(2, success);
-    Assert.assertEquals(1, limited);
-    Assert.assertEquals(3, testRequestLogger.getSqlQueryLogs().size());
-    Assert.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty());
+    Assertions.assertEquals(2, success);
+    Assertions.assertEquals(1, limited);
+    Assertions.assertEquals(3, testRequestLogger.getSqlQueryLogs().size());
+    Assertions.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty());
     stubServiceEmitter.verifyEmitted("sqlQuery/time", 3);
     Map<Integer, Long> codeFrequencies = stubServiceEmitter.getMetricEvents("sqlQuery/time").stream()
                                                            .map(event -> event.toMap())
@@ -1892,7 +1892,7 @@ public class SqlResourceTest extends CalciteTestBase
                                                                code -> code,
                                                                Collectors.counting()
                                                            ));
-    Assert.assertEquals(Map.of(200, 2L, 429, 1L), codeFrequencies);
+    Assertions.assertEquals(Map.of(200, 2L, 429, 1L), codeFrequencies);
   }
 
   @Test
@@ -1925,9 +1925,9 @@ public class SqlResourceTest extends CalciteTestBase
         QueryTimeoutException.class.getName(),
         ""
     );
-    Assert.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty());
+    Assertions.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty());
     stubServiceEmitter.verifyEmitted("sqlQuery/time", 1);
-    Assert.assertEquals(504, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
+    Assertions.assertEquals(504, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
   }
 
   @Test
@@ -1945,13 +1945,13 @@ public class SqlResourceTest extends CalciteTestBase
             makeRegularUserReq()
         )
     );
-    Assert.assertTrue(validateAndAuthorizeLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS));
-    Assert.assertTrue(lifecycleAddLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS));
+    Assertions.assertTrue(validateAndAuthorizeLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS));
+    Assertions.assertTrue(lifecycleAddLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS));
     Response cancelResponse = resource.cancelQuery(sqlQueryId, makeRequestForCancel());
     planLatch.countDown();
-    Assert.assertEquals(Status.ACCEPTED.getStatusCode(), cancelResponse.getStatus());
+    Assertions.assertEquals(Status.ACCEPTED.getStatusCode(), cancelResponse.getStatus());
 
-    Assert.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty());
+    Assertions.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty());
 
     Response queryResponse = future.get();
     assertStatusAndCommonHeaders(queryResponse, Status.INTERNAL_SERVER_ERROR.getStatusCode());
@@ -1964,7 +1964,7 @@ public class SqlResourceTest extends CalciteTestBase
         ""
     );
     stubServiceEmitter.verifyEmitted("sqlQuery/time", 1);
-    Assert.assertEquals(500, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
+    Assertions.assertEquals(500, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
   }
 
   @Test
@@ -1981,12 +1981,12 @@ public class SqlResourceTest extends CalciteTestBase
             makeRegularUserReq()
         )
     );
-    Assert.assertTrue(planLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS));
+    Assertions.assertTrue(planLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS));
     Response cancelResponse = resource.cancelQuery(sqlQueryId, makeRequestForCancel());
     execLatch.countDown();
-    Assert.assertEquals(Status.ACCEPTED.getStatusCode(), cancelResponse.getStatus());
+    Assertions.assertEquals(Status.ACCEPTED.getStatusCode(), cancelResponse.getStatus());
 
-    Assert.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty());
+    Assertions.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty());
 
     Response queryResponse = future.get();
     assertStatusAndCommonHeaders(queryResponse, Status.INTERNAL_SERVER_ERROR.getStatusCode());
@@ -1994,7 +1994,7 @@ public class SqlResourceTest extends CalciteTestBase
     ErrorResponse exception = deserializeResponse(queryResponse, ErrorResponse.class);
     validateLegacyQueryExceptionErrorResponse(exception, "Query cancelled", null, "");
     stubServiceEmitter.verifyEmitted("sqlQuery/time", 1);
-    Assert.assertEquals(500, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
+    Assertions.assertEquals(500, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
   }
 
   @Test
@@ -2011,15 +2011,15 @@ public class SqlResourceTest extends CalciteTestBase
             makeRegularUserReq()
         )
     );
-    Assert.assertTrue(planLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS));
+    Assertions.assertTrue(planLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS));
     Response cancelResponse = resource.cancelQuery("invalidQuery", makeRequestForCancel());
-    Assert.assertEquals(Status.NOT_FOUND.getStatusCode(), cancelResponse.getStatus());
+    Assertions.assertEquals(Status.NOT_FOUND.getStatusCode(), cancelResponse.getStatus());
 
-    Assert.assertFalse(lifecycleManager.getAll(sqlQueryId).isEmpty());
+    Assertions.assertFalse(lifecycleManager.getAll(sqlQueryId).isEmpty());
 
     execLatch.countDown();
     MockHttpServletResponse queryResponse = future.get();
-    Assert.assertEquals(Status.OK.getStatusCode(), queryResponse.getStatus());
+    Assertions.assertEquals(Status.OK.getStatusCode(), queryResponse.getStatus());
   }
 
   @Test
@@ -2036,15 +2036,15 @@ public class SqlResourceTest extends CalciteTestBase
             makeSuperUserReq()
         )
     );
-    Assert.assertTrue(planLatch.await(3, TimeUnit.SECONDS));
+    Assertions.assertTrue(planLatch.await(3, TimeUnit.SECONDS));
     Response cancelResponse = resource.cancelQuery(sqlQueryId, makeRequestForCancel());
-    Assert.assertEquals(Status.FORBIDDEN.getStatusCode(), cancelResponse.getStatus());
+    Assertions.assertEquals(Status.FORBIDDEN.getStatusCode(), cancelResponse.getStatus());
 
-    Assert.assertFalse(lifecycleManager.getAll(sqlQueryId).isEmpty());
+    Assertions.assertFalse(lifecycleManager.getAll(sqlQueryId).isEmpty());
 
     execLatch.countDown();
     MockHttpServletResponse queryResponse = future.get();
-    Assert.assertEquals(Status.OK.getStatusCode(), queryResponse.getStatus());
+    Assertions.assertEquals(Status.OK.getStatusCode(), queryResponse.getStatus());
   }
 
   @Test
@@ -2076,9 +2076,9 @@ public class SqlResourceTest extends CalciteTestBase
         "2000'"
     );
     checkSqlRequestLog(false);
-    Assert.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty());
+    Assertions.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty());
     stubServiceEmitter.verifyEmitted("sqlQuery/time", 1);
-    Assert.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
+    Assertions.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
   }
 
   @Test
@@ -2096,7 +2096,7 @@ public class SqlResourceTest extends CalciteTestBase
     );
     checkSqlRequestLog(false);
     stubServiceEmitter.verifyEmitted("sqlQuery/time", 1);
-    Assert.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
+    Assertions.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
   }
 
   private void checkSqlRequestLog(boolean success)
@@ -2107,21 +2107,21 @@ public class SqlResourceTest extends CalciteTestBase
   @SuppressWarnings("unchecked")
   private void checkSqlRequestLog(boolean success, String user)
   {
-    Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
+    Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
 
     final Map<String, Object> stats = testRequestLogger.getSqlQueryLogs().get(0).getQueryStats().getStats();
     final Map<String, Object> queryContext = (Map<String, Object>) testRequestLogger.getSqlQueryLogs()
                                                                                     .get(0)
                                                                                     .getSqlQueryContext();
-    Assert.assertEquals(success, stats.get("success"));
-    Assert.assertEquals(user, stats.get("identity"));
-    Assert.assertTrue(stats.containsKey("sqlQuery/time"));
-    Assert.assertTrue(stats.containsKey("sqlQuery/planningTimeMs"));
-    Assert.assertTrue(queryContext.containsKey(QueryContexts.CTX_SQL_QUERY_ID));
+    Assertions.assertEquals(success, stats.get("success"));
+    Assertions.assertEquals(user, stats.get("identity"));
+    Assertions.assertTrue(stats.containsKey("sqlQuery/time"));
+    Assertions.assertTrue(stats.containsKey("sqlQuery/planningTimeMs"));
+    Assertions.assertTrue(queryContext.containsKey(QueryContexts.CTX_SQL_QUERY_ID));
     if (success) {
-      Assert.assertTrue(stats.containsKey("sqlQuery/bytes"));
+      Assertions.assertTrue(stats.containsKey("sqlQuery/bytes"));
     } else {
-      Assert.assertTrue(stats.containsKey("exception"));
+      Assertions.assertTrue(stats.containsKey("exception"));
     }
   }
 
@@ -2188,7 +2188,7 @@ public class SqlResourceTest extends CalciteTestBase
 
     final Object explicitQueryId = query.getContext().get("queryId");
     final Object explicitSqlQueryId = query.getContext().get("sqlQueryId");
-    Assert.assertNull(resource.doPost(query, req));
+    Assertions.assertNull(resource.doPost(query, req));
 
     final Object actualQueryId = response.getHeader(QueryResource.QUERY_ID_RESPONSE_HEADER);
     final Object actualSqlQueryId = response.getHeader(SqlResource.SQL_QUERY_ID_RESPONSE_HEADER);
@@ -2199,10 +2199,10 @@ public class SqlResourceTest extends CalciteTestBase
 
   private void assertStatusAndCommonHeaders(MockHttpServletResponse queryResponse, int statusCode)
   {
-    Assert.assertEquals(statusCode, queryResponse.getStatus());
-    Assert.assertEquals("application/json", queryResponse.getContentType());
-    Assert.assertNotNull(queryResponse.getHeader(QueryResource.QUERY_ID_RESPONSE_HEADER));
-    Assert.assertNotNull(queryResponse.getHeader(SqlResource.SQL_QUERY_ID_RESPONSE_HEADER));
+    Assertions.assertEquals(statusCode, queryResponse.getStatus());
+    Assertions.assertEquals("application/json", queryResponse.getContentType());
+    Assertions.assertNotNull(queryResponse.getHeader(QueryResource.QUERY_ID_RESPONSE_HEADER));
+    Assertions.assertNotNull(queryResponse.getHeader(SqlResource.SQL_QUERY_ID_RESPONSE_HEADER));
   }
 
   private <T> T deserializeResponse(MockHttpServletResponse resp, Class<T> clazz) throws IOException
@@ -2270,10 +2270,10 @@ public class SqlResourceTest extends CalciteTestBase
 
   private void assertStatusAndCommonHeaders(Response queryResponse, int statusCode)
   {
-    Assert.assertEquals(statusCode, queryResponse.getStatus());
-    Assert.assertEquals("application/json", getContentType(queryResponse));
-    Assert.assertNotNull(getHeader(queryResponse, QueryResource.QUERY_ID_RESPONSE_HEADER));
-    Assert.assertNotNull(getHeader(queryResponse, SqlResource.SQL_QUERY_ID_RESPONSE_HEADER));
+    Assertions.assertEquals(statusCode, queryResponse.getStatus());
+    Assertions.assertEquals("application/json", getContentType(queryResponse));
+    Assertions.assertNotNull(getHeader(queryResponse, QueryResource.QUERY_ID_RESPONSE_HEADER));
+    Assertions.assertNotNull(getHeader(queryResponse, SqlResource.SQL_QUERY_ID_RESPONSE_HEADER));
   }
 
   private void validateQueryIds(
@@ -2285,19 +2285,19 @@ public class SqlResourceTest extends CalciteTestBase
   {
     if (explicitQueryId == null) {
       if (null != explicitSqlQueryId) {
-        Assert.assertEquals(explicitSqlQueryId, actualQueryId);
-        Assert.assertEquals(explicitSqlQueryId, actualSqlQueryId);
+        Assertions.assertEquals(explicitSqlQueryId, actualQueryId);
+        Assertions.assertEquals(explicitSqlQueryId, actualSqlQueryId);
       } else {
-        Assert.assertNotNull(actualQueryId);
-        Assert.assertNotNull(actualSqlQueryId);
+        Assertions.assertNotNull(actualQueryId);
+        Assertions.assertNotNull(actualSqlQueryId);
       }
     } else {
       if (explicitSqlQueryId == null) {
-        Assert.assertEquals(explicitQueryId, actualQueryId);
-        Assert.assertEquals(explicitQueryId, actualSqlQueryId);
+        Assertions.assertEquals(explicitQueryId, actualQueryId);
+        Assertions.assertEquals(explicitQueryId, actualSqlQueryId);
       } else {
-        Assert.assertEquals(explicitQueryId, actualQueryId);
-        Assert.assertEquals(explicitSqlQueryId, actualSqlQueryId);
+        Assertions.assertEquals(explicitQueryId, actualQueryId);
+        Assertions.assertEquals(explicitSqlQueryId, actualSqlQueryId);
       }
     }
   }
@@ -2496,17 +2496,17 @@ public class SqlResourceTest extends CalciteTestBase
       String messageContainsString
   )
   {
-    Assert.assertNotNull(errorResponse);
+    Assertions.assertNotNull(errorResponse);
 
     DruidException exception = errorResponse.getUnderlyingException();
 
-    Assert.assertEquals(errorCode, exception.getErrorCode());
-    Assert.assertEquals(targetPersona, exception.getTargetPersona());
-    Assert.assertEquals(category, exception.getCategory());
+    Assertions.assertEquals(errorCode, exception.getErrorCode());
+    Assertions.assertEquals(targetPersona, exception.getTargetPersona());
+    Assertions.assertEquals(category, exception.getCategory());
     if (messageContainsString == null) {
-      Assert.assertNull(exception.getMessage());
+      Assertions.assertNull(exception.getMessage());
     } else {
-      assertThat(exception.getMessage(), CoreMatchers.containsString(messageContainsString));
+      Assertions.assertTrue(exception.getMessage().contains(messageContainsString));
     }
 
     return exception;
@@ -2518,7 +2518,7 @@ public class SqlResourceTest extends CalciteTestBase
   )
   {
     final DruidException exception = validateInvalidInputError(response, containsString);
-    Assert.assertEquals("sql", exception.getContextValue("sourceType"));
+    Assertions.assertEquals("sql", exception.getContextValue("sourceType"));
 
     return exception;
   }
@@ -2550,8 +2550,8 @@ public class SqlResourceTest extends CalciteTestBase
         messageContainsString
     );
 
-    Assert.assertEquals(legacyCode, exception.getContextValue("legacyErrorCode"));
-    Assert.assertEquals(errorClass, exception.getContextValue("errorClass"));
+    Assertions.assertEquals(legacyCode, exception.getContextValue("legacyErrorCode"));
+    Assertions.assertEquals(errorClass, exception.getContextValue("errorClass"));
 
     return exception;
   }


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org