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

(druid) branch master updated: test(processing): migrate query tests to JUnit 5 (#19980)

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

FrankChen021 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 cb26014728a test(processing): migrate query tests to JUnit 5 (#19980)
cb26014728a is described below

commit cb26014728ab3239bc8d7391f9cf6466e63905b0
Author: Frank Chen <fr...@outlook.com>
AuthorDate: Mon Aug 17 15:42:09 2026 +0800

    test(processing): migrate query tests to JUnit 5 (#19980)
    
    * test(processing): migrate query tests to JUnit 5
    
    * test(processing): address migration CI findings
    
    * test(processing): preserve JUnit 4 exception message semantics
    
    * test(benchmarks): move TopN query benchmark
    
    * test(processing): remove JupiterAssertions helper
    
    * test(processing): remove ExpectThrows adapter
    
    * test(processing): remove unread test variable
---
 .../benchmark/query}/TopNQueryRunnerBenchmark.java |  32 +-
 processing/pom.xml                                 |   6 +
 .../query/ChainedExecutionQueryRunnerTest.java     | 106 +--
 .../org/apache/druid/query/JoinDataSourceTest.java |  85 +-
 .../druid/query/MultiValuedDimensionTest.java      |  86 +-
 .../query/PrioritizedExecutorServiceTest.java      |  42 +-
 .../java/org/apache/druid/query/QueriesTest.java   |  24 +-
 .../org/apache/druid/query/QueryContextTest.java   |  14 +-
 .../ResultGranularTimestampComparatorTest.java     |  26 +-
 .../apache/druid/query/SchemaEvolutionTest.java    |  65 +-
 .../query/aggregation/AggregationTestHelper.java   |  52 ++
 .../ExpressionLambdaAggregationTest.java           |  29 +-
 .../ExpressionLambdaAggregatorFactoryTest.java     | 164 ++--
 .../query/aggregation/FilteredAggregatorTest.java  |  17 +-
 .../aggregation/GroupingAggregatorFactoryTest.java |  89 +-
 .../aggregation/MetricManipulatorFnsTest.java      |  31 +-
 .../SerializablePairLongStringBufferStoreTest.java |  74 +-
 .../aggregation/StringColumnAggregationTest.java   | 103 +--
 .../cardinality/CardinalityAggregatorTest.java     |  60 +-
 .../last/StringLastVectorAggregatorTest.java       |  55 +-
 .../hyperloglog/HyperUniquesAggregationTest.java   |  33 +-
 .../mean/DoubleMeanAggregationTest.java            |  68 +-
 .../FinalizingFieldAccessPostAggregatorTest.java   |  38 +-
 .../simd/SimdDoubleMeanVectorAggregatorTest.java   |  18 +-
 .../simd/SimdMinMaxVectorAggregatorTest.java       |  22 +-
 .../simd/SimdSumVectorAggregatorTest.java          |  38 +-
 .../druid/query/context/ResponseContextTest.java   | 103 ++-
 .../DataSourceMetadataQueryTest.java               |  38 +-
 .../groupby/ComplexDimensionGroupByQueryTest.java  |  27 +-
 ...GroupByLimitPushDownInsufficientBufferTest.java |  32 +-
 .../GroupByLimitPushDownMultiNodeMergeTest.java    |  44 +-
 .../query/groupby/GroupByQueryMergeBufferTest.java |  71 +-
 .../groupby/GroupByQueryQueryToolChestTest.java    | 174 ++--
 .../groupby/GroupByQueryRunnerFailureTest.java     | 124 +--
 .../query/groupby/GroupByQueryRunnerTest.java      | 943 ++++++++++++++-------
 .../groupby/GroupByTimeseriesQueryRunnerTest.java  |  77 +-
 .../query/groupby/NestedDataGroupByQueryTest.java  |  52 +-
 .../query/groupby/NestedGroupByArrayQueryTest.java |  56 +-
 .../query/groupby/NestedQueryPushDownTest.java     |  54 +-
 .../groupby/UnnestGroupByQueryRunnerTest.java      | 149 +++-
 .../epinephelinae/ConcurrentGrouperTest.java       |  38 +-
 .../LimitedBufferHashGrouperTest.java              | 171 ++--
 .../groupby/epinephelinae/SpillingGrouperTest.java | 160 ++--
 ...ixedWidthGroupByColumnSelectorStrategyTest.java | 125 +--
 .../groupby/orderby/DefaultLimitSpecTest.java      |  66 +-
 .../druid/query/lookup/LookupExtractionFnTest.java |  71 +-
 .../druid/query/metadata/SegmentAnalyzerTest.java  | 142 ++--
 .../SegmentMetadataQueryQueryToolChestTest.java    | 108 +--
 .../query/metadata/SegmentMetadataQueryTest.java   | 123 +--
 .../metadata/SegmentMetadataUnionQueryTest.java    |  11 +-
 .../operator/window/RowsAndColumnsHelper.java      |  70 +-
 .../druid/query/planning/ExecutionVertexTest.java  | 356 ++++----
 .../rowsandcols/column/ColumnAccessorsTest.java    |  18 +-
 .../query/scan/MultiSegmentScanQueryTest.java      |  25 +-
 .../druid/query/scan/NestedDataScanQueryTest.java  | 128 ++-
 .../query/scan/ScanQueryQueryToolChestTest.java    |  64 +-
 .../query/scan/ScanQueryResultOrderingTest.java    |  18 +-
 .../druid/query/scan/ScanQueryRunnerTest.java      |  52 +-
 .../org/apache/druid/query/scan/ScanQueryTest.java |  95 ++-
 .../scan/ScanResultValueFramesIterableTest.java    |  28 +-
 .../druid/query/search/SearchBinaryFnTest.java     |  30 +-
 .../druid/query/search/SearchQueryRunnerTest.java  |  22 +-
 .../timeboundary/TimeBoundaryQueryRunnerTest.java  |  75 +-
 .../timeseries/NestedDataTimeseriesQueryTest.java  |  35 +-
 .../timeseries/TimeSeriesUnionQueryRunnerTest.java |  11 +-
 .../TimeseriesQueryQueryToolChestTest.java         |  35 +-
 .../timeseries/TimeseriesQueryRunnerBonusTest.java |  29 +-
 .../timeseries/TimeseriesQueryRunnerTest.java      | 322 +++----
 .../query/timeseries/TimeseriesQueryTest.java      |  37 +-
 .../druid/query/topn/NestedDataTopNQueryTest.java  |  45 +-
 .../apache/druid/query/topn/TopNBinaryFnTest.java  |  20 +-
 .../query/topn/TopNQueryQueryToolChestTest.java    |  30 +-
 .../druid/query/topn/TopNQueryRunnerTest.java      |  43 +-
 .../druid/query/topn/TopNUnionQueryTest.java       |  16 +-
 .../query/topn/UnnestTopNQueryRunnerTest.java      |  21 +-
 75 files changed, 3268 insertions(+), 2693 deletions(-)

diff --git a/processing/src/test/java/org/apache/druid/query/topn/TopNQueryRunnerBenchmark.java b/benchmarks/src/test/java/org/apache/druid/benchmark/query/TopNQueryRunnerBenchmark.java
similarity index 88%
rename from processing/src/test/java/org/apache/druid/query/topn/TopNQueryRunnerBenchmark.java
rename to benchmarks/src/test/java/org/apache/druid/benchmark/query/TopNQueryRunnerBenchmark.java
index 0e5451846b8..cc6a1c4c494 100644
--- a/processing/src/test/java/org/apache/druid/query/topn/TopNQueryRunnerBenchmark.java
+++ b/benchmarks/src/test/java/org/apache/druid/benchmark/query/TopNQueryRunnerBenchmark.java
@@ -17,10 +17,8 @@
  * under the License.
  */
 
-package org.apache.druid.query.topn;
+package org.apache.druid.benchmark.query;
 
-import com.carrotsearch.junitbenchmarks.AbstractBenchmark;
-import com.carrotsearch.junitbenchmarks.BenchmarkOptions;
 import com.google.common.base.Supplier;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
@@ -31,13 +29,18 @@ import org.apache.druid.query.QueryRunnerFactory;
 import org.apache.druid.query.QueryRunnerTestHelper;
 import org.apache.druid.query.aggregation.DoubleMaxAggregatorFactory;
 import org.apache.druid.query.aggregation.DoubleMinAggregatorFactory;
+import org.apache.druid.query.topn.TopNQuery;
+import org.apache.druid.query.topn.TopNQueryBuilder;
+import org.apache.druid.query.topn.TopNQueryConfig;
+import org.apache.druid.query.topn.TopNQueryQueryToolChest;
+import org.apache.druid.query.topn.TopNQueryRunnerFactory;
 import org.apache.druid.segment.IncrementalIndexSegment;
 import org.apache.druid.segment.QueryableIndexSegment;
 import org.apache.druid.segment.TestIndex;
 import org.apache.druid.timeline.SegmentId;
-import org.junit.BeforeClass;
-import org.junit.Ignore;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 
 import java.nio.ByteBuffer;
 import java.util.HashMap;
@@ -46,8 +49,8 @@ import java.util.Map;
 /**
  * Based on TopNQueryRunnerTest
  */
-@Ignore
-public class TopNQueryRunnerBenchmark extends AbstractBenchmark
+@Disabled
+public class TopNQueryRunnerBenchmark
 {
 
   public enum TestCases
@@ -80,7 +83,7 @@ public class TopNQueryRunnerBenchmark extends AbstractBenchmark
       .build();
   private static final Map<TestCases, QueryRunner> TEST_CASE_MAP = new HashMap<>();
 
-  @BeforeClass
+  @BeforeAll
   public static void setUp()
   {
     QueryRunnerFactory factory = new TopNQueryRunnerFactory(
@@ -126,32 +129,27 @@ public class TopNQueryRunnerBenchmark extends AbstractBenchmark
     );
     //Thread.sleep(10000);
   }
-
-  @BenchmarkOptions(warmupRounds = 10000, benchmarkRounds = 10000)
   @Test
   public void testmMapped()
   {
     TEST_CASE_MAP.get(TestCases.mMappedTestIndex).run(QueryPlus.wrap(QUERY));
   }
 
-  @Ignore
-  @BenchmarkOptions(warmupRounds = 10000, benchmarkRounds = 10000)
+  @Disabled
   @Test
   public void testrtIndex()
   {
     TEST_CASE_MAP.get(TestCases.rtIndex).run(QueryPlus.wrap(QUERY));
   }
 
-  @Ignore
-  @BenchmarkOptions(warmupRounds = 10000, benchmarkRounds = 10000)
+  @Disabled
   @Test
   public void testMerged()
   {
     TEST_CASE_MAP.get(TestCases.mergedRealtimeIndex).run(QueryPlus.wrap(QUERY));
   }
 
-  @Ignore
-  @BenchmarkOptions(warmupRounds = 10000, benchmarkRounds = 10000)
+  @Disabled
   @Test
   public void testOffHeap()
   {
diff --git a/processing/pom.xml b/processing/pom.xml
index fedbfe9c2eb..7611d92bf34 100644
--- a/processing/pom.xml
+++ b/processing/pom.xml
@@ -352,6 +352,12 @@
       <artifactId>junit-jupiter-api</artifactId>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>org.opentest4j</groupId>
+      <artifactId>opentest4j</artifactId>
+      <version>1.3.0</version>
+      <scope>test</scope>
+    </dependency>
     <dependency>
       <groupId>org.junit.jupiter</groupId>
       <artifactId>junit-jupiter-engine</artifactId>
diff --git a/processing/src/test/java/org/apache/druid/query/ChainedExecutionQueryRunnerTest.java b/processing/src/test/java/org/apache/druid/query/ChainedExecutionQueryRunnerTest.java
index 726300d8ae8..a23ad451ac8 100644
--- a/processing/src/test/java/org/apache/druid/query/ChainedExecutionQueryRunnerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/ChainedExecutionQueryRunnerTest.java
@@ -36,10 +36,10 @@ import org.apache.druid.query.timeseries.TimeseriesResultValue;
 import org.easymock.Capture;
 import org.easymock.EasyMock;
 import org.easymock.IAnswer;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+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.mockito.ArgumentCaptor;
 import org.mockito.ArgumentMatchers;
 import org.mockito.Mockito;
@@ -65,7 +65,7 @@ public class ChainedExecutionQueryRunnerTest
   private final Lock neverRelease = new ReentrantLock();
   private QueryProcessingPool processingPool;
 
-  @Before
+  @BeforeEach
   public void setup()
   {
     neverRelease.lock();
@@ -75,13 +75,14 @@ public class ChainedExecutionQueryRunnerTest
     );
   }
 
-  @After
+  @AfterEach
   public void tearDown()
   {
     processingPool.shutdown();
   }
 
-  @Test(timeout = 60_000L)
+  @Test
+  @org.junit.jupiter.api.Timeout(value = 60_000L, unit = java.util.concurrent.TimeUnit.MILLISECONDS)
   public void testQueryCancellation() throws Exception
   {
     ExecutorService exec = PrioritizedExecutorService.create(
@@ -164,7 +165,7 @@ public class ChainedExecutionQueryRunnerTest
     queriesStarted.await();
 
     // cancel the query
-    Assert.assertTrue(capturedFuture.hasCaptured());
+    Assertions.assertTrue(capturedFuture.hasCaptured());
     ListenableFuture future = capturedFuture.getValue();
     future.cancel(true);
 
@@ -173,38 +174,39 @@ public class ChainedExecutionQueryRunnerTest
       resultFuture.get();
     }
     catch (ExecutionException e) {
-      Assert.assertTrue(e.getCause() instanceof QueryInterruptedException);
+      Assertions.assertTrue(e.getCause() instanceof QueryInterruptedException);
       cause = (QueryInterruptedException) e.getCause();
     }
     queriesInterrupted.await();
-    Assert.assertNotNull(cause);
-    Assert.assertTrue(future.isCancelled());
+    Assertions.assertNotNull(cause);
+    Assertions.assertTrue(future.isCancelled());
 
     DyingQueryRunner interrupted1 = interrupted.poll();
     synchronized (interrupted1) {
-      Assert.assertTrue("runner 1 started", interrupted1.hasStarted);
-      Assert.assertTrue("runner 1 interrupted", interrupted1.interrupted);
+      Assertions.assertTrue(interrupted1.hasStarted, "runner 1 started");
+      Assertions.assertTrue(interrupted1.interrupted, "runner 1 interrupted");
     }
     DyingQueryRunner interrupted2 = interrupted.poll();
     synchronized (interrupted2) {
-      Assert.assertTrue("runner 2 started", interrupted2.hasStarted);
-      Assert.assertTrue("runner 2 interrupted", interrupted2.interrupted);
+      Assertions.assertTrue(interrupted2.hasStarted, "runner 2 started");
+      Assertions.assertTrue(interrupted2.interrupted, "runner 2 interrupted");
     }
     runners.remove(interrupted1);
     runners.remove(interrupted2);
     DyingQueryRunner remainingRunner = runners.iterator().next();
     synchronized (remainingRunner) {
-      Assert.assertTrue("runner 3 should be interrupted or not have started",
-                        !remainingRunner.hasStarted || remainingRunner.interrupted);
+      Assertions.assertTrue(!remainingRunner.hasStarted || remainingRunner.interrupted,
+                        "runner 3 should be interrupted or not have started");
     }
-    Assert.assertFalse("runner 1 not completed", interrupted1.hasCompleted);
-    Assert.assertFalse("runner 2 not completed", interrupted2.hasCompleted);
-    Assert.assertFalse("runner 3 not completed", remainingRunner.hasCompleted);
+    Assertions.assertFalse(interrupted1.hasCompleted, "runner 1 not completed");
+    Assertions.assertFalse(interrupted2.hasCompleted, "runner 2 not completed");
+    Assertions.assertFalse(remainingRunner.hasCompleted, "runner 3 not completed");
 
     EasyMock.verify(watcher);
   }
 
-  @Test(timeout = 60_000L)
+  @Test
+  @org.junit.jupiter.api.Timeout(value = 60_000L, unit = java.util.concurrent.TimeUnit.MILLISECONDS)
   public void testQueryTimeout() throws Exception
   {
     ExecutorService exec = PrioritizedExecutorService.create(
@@ -288,7 +290,7 @@ public class ChainedExecutionQueryRunnerTest
     queryIsRegistered.await();
     queriesStarted.await();
 
-    Assert.assertTrue(capturedFuture.hasCaptured());
+    Assertions.assertTrue(capturedFuture.hasCaptured());
     ListenableFuture future = capturedFuture.getValue();
 
     // wait for query to time out
@@ -297,34 +299,34 @@ public class ChainedExecutionQueryRunnerTest
       resultFuture.get();
     }
     catch (ExecutionException e) {
-      Assert.assertTrue(e.getCause() instanceof QueryTimeoutException);
-      Assert.assertEquals("Query timeout", ((QueryTimeoutException) e.getCause()).getErrorCode());
+      Assertions.assertTrue(e.getCause() instanceof QueryTimeoutException);
+      Assertions.assertEquals("Query timeout", ((QueryTimeoutException) e.getCause()).getErrorCode());
       cause = (QueryTimeoutException) e.getCause();
     }
     queriesInterrupted.await();
-    Assert.assertNotNull(cause);
-    Assert.assertTrue(future.isCancelled());
+    Assertions.assertNotNull(cause);
+    Assertions.assertTrue(future.isCancelled());
 
     DyingQueryRunner interrupted1 = interrupted.poll();
     synchronized (interrupted1) {
-      Assert.assertTrue("runner 1 started", interrupted1.hasStarted);
-      Assert.assertTrue("runner 1 interrupted", interrupted1.interrupted);
+      Assertions.assertTrue(interrupted1.hasStarted, "runner 1 started");
+      Assertions.assertTrue(interrupted1.interrupted, "runner 1 interrupted");
     }
     DyingQueryRunner interrupted2 = interrupted.poll();
     synchronized (interrupted2) {
-      Assert.assertTrue("runner 2 started", interrupted2.hasStarted);
-      Assert.assertTrue("runner 2 interrupted", interrupted2.interrupted);
+      Assertions.assertTrue(interrupted2.hasStarted, "runner 2 started");
+      Assertions.assertTrue(interrupted2.interrupted, "runner 2 interrupted");
     }
     runners.remove(interrupted1);
     runners.remove(interrupted2);
     DyingQueryRunner remainingRunner = runners.iterator().next();
     synchronized (remainingRunner) {
-      Assert.assertTrue("runner 3 should be interrupted or not have started",
-                        !remainingRunner.hasStarted || remainingRunner.interrupted);
+      Assertions.assertTrue(!remainingRunner.hasStarted || remainingRunner.interrupted,
+                        "runner 3 should be interrupted or not have started");
     }
-    Assert.assertFalse("runner 1 not completed", interrupted1.hasCompleted);
-    Assert.assertFalse("runner 2 not completed", interrupted2.hasCompleted);
-    Assert.assertFalse("runner 3 not completed", remainingRunner.hasCompleted);
+    Assertions.assertFalse(interrupted1.hasCompleted, "runner 1 not completed");
+    Assertions.assertFalse(interrupted2.hasCompleted, "runner 2 not completed");
+    Assertions.assertFalse(remainingRunner.hasCompleted, "runner 3 not completed");
 
     EasyMock.verify(watcher);
   }
@@ -355,10 +357,11 @@ public class ChainedExecutionQueryRunnerTest
     ArgumentCaptor<PrioritizedQueryRunnerCallable> captor = ArgumentCaptor.forClass(PrioritizedQueryRunnerCallable.class);
     Mockito.verify(queryProcessingPool, Mockito.times(2)).submitRunnerTask(captor.capture());
     List<QueryRunner> actual = captor.getAllValues().stream().map(PrioritizedQueryRunnerCallable::getRunner).collect(Collectors.toList());
-    Assert.assertEquals(runners, actual);
+    Assertions.assertEquals(runners, actual);
   }
 
-  @Test(timeout = 10_000L)
+  @Test
+  @org.junit.jupiter.api.Timeout(value = 10_000L, unit = java.util.concurrent.TimeUnit.MILLISECONDS)
   public void testPerSegmentTimeout()
   {
     QueryRunner<Integer> slowRunner = (queryPlus, responseContext) -> {
@@ -408,18 +411,19 @@ public class ChainedExecutionQueryRunnerTest
       thrown = e;
     }
 
-    Assert.assertNull("No results expected due to timeout", results);
-    Assert.assertNotNull("Exception should be thrown", thrown);
-    Assert.assertTrue(
-        "Should be QueryTimeoutException or caused by it",
-        Throwables.getRootCause(thrown) instanceof QueryTimeoutException
+    Assertions.assertNull(results, "No results expected due to timeout");
+    Assertions.assertNotNull(thrown, "Exception should be thrown");
+    Assertions.assertTrue(
+        Throwables.getRootCause(thrown) instanceof QueryTimeoutException,
+        "Should be QueryTimeoutException or caused by it"
     );
-    Assert.assertEquals("Query timeout, cancelling pending results for query [test]. Per-segment timeout exceeded.", thrown.getMessage());
+    Assertions.assertEquals("Query timeout, cancelling pending results for query [test]. Per-segment timeout exceeded.", thrown.getMessage());
 
     EasyMock.verify(watcher);
   }
 
-  @Test(timeout = 5_000L)
+  @Test
+  @org.junit.jupiter.api.Timeout(value = 5_000L, unit = java.util.concurrent.TimeUnit.MILLISECONDS)
   public void test_perSegmentTimeout_crossQuery() throws Exception
   {
     final CountDownLatch slowStarted = new CountDownLatch(2);
@@ -487,15 +491,15 @@ public class ChainedExecutionQueryRunnerTest
           fastQuery)).toList());
 
       boolean fastStartedEarly = fastStarted.await(500, TimeUnit.MILLISECONDS);
-      Assert.assertFalse(
-          "Fast query should be blocked and not started while slow queries are running",
-          fastStartedEarly
+      Assertions.assertFalse(
+          fastStartedEarly,
+          "Fast query should be blocked and not started while slow queries are running"
       );
 
-      ExecutionException ex = Assert.assertThrows(ExecutionException.class, slowFuture::get);
-      Assert.assertTrue(Throwables.getRootCause(ex) instanceof QueryTimeoutException);
-      Assert.assertEquals("Query timeout, cancelling pending results for query [slow]. Per-segment timeout exceeded.", ex.getCause().getMessage());
-      Assert.assertEquals(
+      ExecutionException ex = Assertions.assertThrows(ExecutionException.class, slowFuture::get);
+      Assertions.assertTrue(Throwables.getRootCause(ex) instanceof QueryTimeoutException);
+      Assertions.assertEquals("Query timeout, cancelling pending results for query [slow]. Per-segment timeout exceeded.", ex.getCause().getMessage());
+      Assertions.assertEquals(
           Collections.singletonList(
               new Result<>(null, new TimeseriesResultValue(ImmutableMap.of("count", 1)))
           ), fastFuture.get()
diff --git a/processing/src/test/java/org/apache/druid/query/JoinDataSourceTest.java b/processing/src/test/java/org/apache/druid/query/JoinDataSourceTest.java
index 8d4dbf8c12d..b638be61edb 100644
--- a/processing/src/test/java/org/apache/druid/query/JoinDataSourceTest.java
+++ b/processing/src/test/java/org/apache/druid/query/JoinDataSourceTest.java
@@ -42,8 +42,9 @@ import org.apache.druid.segment.virtual.ExpressionVirtualColumn;
 import org.easymock.Mock;
 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;
+
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Optional;
@@ -89,63 +90,63 @@ public class JoinDataSourceTest
   @Test
   public void test_getTableNames_tableToTable()
   {
-    Assert.assertEquals(ImmutableSet.of("foo", "bar"), joinTableToTable.getTableNames());
+    Assertions.assertEquals(ImmutableSet.of("foo", "bar"), joinTableToTable.getTableNames());
   }
 
   @Test
   public void test_getTableNames_tableToLookup()
   {
-    Assert.assertEquals(Collections.singleton("foo"), joinTableToLookup.getTableNames());
+    Assertions.assertEquals(Collections.singleton("foo"), joinTableToLookup.getTableNames());
   }
 
   @Test
   public void test_getChildren_tableToTable()
   {
-    Assert.assertEquals(ImmutableList.of(fooTable, barTable), joinTableToTable.getChildren());
+    Assertions.assertEquals(ImmutableList.of(fooTable, barTable), joinTableToTable.getChildren());
   }
 
   @Test
   public void test_getChildren_tableToLookup()
   {
-    Assert.assertEquals(ImmutableList.of(fooTable, lookylooLookup), joinTableToLookup.getChildren());
+    Assertions.assertEquals(ImmutableList.of(fooTable, lookylooLookup), joinTableToLookup.getChildren());
   }
 
   @Test
   public void test_isCacheable_tableToTable()
   {
-    Assert.assertTrue(joinTableToTable.isCacheable(true));
-    Assert.assertTrue(joinTableToTable.isCacheable(false));
+    Assertions.assertTrue(joinTableToTable.isCacheable(true));
+    Assertions.assertTrue(joinTableToTable.isCacheable(false));
   }
 
   @Test
   public void test_isCacheable_lookup()
   {
-    Assert.assertFalse(joinTableToLookup.isCacheable(true));
-    Assert.assertFalse(joinTableToLookup.isCacheable(false));
+    Assertions.assertFalse(joinTableToLookup.isCacheable(true));
+    Assertions.assertFalse(joinTableToLookup.isCacheable(false));
   }
 
   @Test
   public void test_isProcessable_tableToTable()
   {
-    Assert.assertFalse(joinTableToTable.isProcessable());
+    Assertions.assertFalse(joinTableToTable.isProcessable());
   }
 
   @Test
   public void test_isProcessable_tableToLookup()
   {
-    Assert.assertTrue(joinTableToLookup.isProcessable());
+    Assertions.assertTrue(joinTableToLookup.isProcessable());
   }
 
   @Test
   public void test_isGlobal_tableToTable()
   {
-    Assert.assertFalse(joinTableToTable.isGlobal());
+    Assertions.assertFalse(joinTableToTable.isGlobal());
   }
 
   @Test
   public void test_isGlobal_tableToLookup()
   {
-    Assert.assertFalse(joinTableToLookup.isGlobal());
+    Assertions.assertFalse(joinTableToLookup.isGlobal());
   }
 
   @Test
@@ -163,7 +164,7 @@ public class JoinDataSourceTest
   {
     final DataSource transformed = joinTableToTable.withChildren(ImmutableList.of(fooTable, lookylooLookup));
 
-    Assert.assertEquals(joinTableToLookup, transformed);
+    Assertions.assertEquals(joinTableToLookup, transformed);
   }
 
   @Test
@@ -197,7 +198,7 @@ public class JoinDataSourceTest
         DataSource.class
     );
 
-    Assert.assertEquals(joinDataSource, deserialized);
+    Assertions.assertEquals(joinDataSource, deserialized);
   }
 
   @Test
@@ -237,7 +238,7 @@ public class JoinDataSourceTest
         null,
         JoinAlgorithm.BROADCAST
     );
-    Assert.assertEquals(null, dataSource.getLeftFilter());
+    Assertions.assertEquals(null, dataSource.getLeftFilter());
   }
 
   @Test
@@ -254,7 +255,7 @@ public class JoinDataSourceTest
         null,
         JoinAlgorithm.BROADCAST
     );
-    Assert.assertEquals(dataSource.getVirtualColumnCandidates(), ImmutableSet.of("x"));
+    Assertions.assertEquals(dataSource.getVirtualColumnCandidates(), ImmutableSet.of("x"));
   }
 
   @Test
@@ -274,7 +275,7 @@ public class JoinDataSourceTest
 
     Optional<byte[]> cacheKey = Optional.ofNullable(dataSource.getCacheKey());
 
-    Assert.assertTrue(cacheKey.isPresent());
+    Assertions.assertTrue(cacheKey.isPresent());
   }
 
   @Test
@@ -309,9 +310,9 @@ public class JoinDataSourceTest
     byte[] cacheKey1 = joinDataSource.getCacheKey();
     byte[] cacheKey2 = joinDataSource1.getCacheKey();
 
-    Assert.assertNotEquals(cacheKey1.length, 0);
-    Assert.assertNotEquals(cacheKey2.length, 0);
-    Assert.assertTrue(Arrays.equals(cacheKey1, cacheKey2));
+    Assertions.assertNotEquals(cacheKey1.length, 0);
+    Assertions.assertNotEquals(cacheKey2.length, 0);
+    Assertions.assertTrue(Arrays.equals(cacheKey1, cacheKey2));
   }
 
   @Test
@@ -346,9 +347,9 @@ public class JoinDataSourceTest
     byte[] cacheKey1 = joinDataSource.getCacheKey();
     byte[] cacheKey2 = joinDataSource1.getCacheKey();
 
-    Assert.assertNotEquals(cacheKey1.length, 0);
-    Assert.assertNotEquals(cacheKey2.length, 0);
-    Assert.assertFalse(Arrays.equals(cacheKey1, cacheKey2));
+    Assertions.assertNotEquals(cacheKey1.length, 0);
+    Assertions.assertNotEquals(cacheKey2.length, 0);
+    Assertions.assertFalse(Arrays.equals(cacheKey1, cacheKey2));
   }
 
   @Test
@@ -383,9 +384,9 @@ public class JoinDataSourceTest
     byte[] cacheKey1 = joinDataSource.getCacheKey();
     byte[] cacheKey2 = joinDataSource1.getCacheKey();
 
-    Assert.assertNotEquals(cacheKey1.length, 0);
-    Assert.assertNotEquals(cacheKey2.length, 0);
-    Assert.assertFalse(Arrays.equals(cacheKey1, cacheKey2));
+    Assertions.assertNotEquals(cacheKey1.length, 0);
+    Assertions.assertNotEquals(cacheKey2.length, 0);
+    Assertions.assertFalse(Arrays.equals(cacheKey1, cacheKey2));
   }
 
   @Test
@@ -420,9 +421,9 @@ public class JoinDataSourceTest
     byte[] cacheKey1 = joinDataSource.getCacheKey();
     byte[] cacheKey2 = joinDataSource1.getCacheKey();
 
-    Assert.assertNotEquals(cacheKey1.length, 0);
-    Assert.assertNotEquals(cacheKey2.length, 0);
-    Assert.assertFalse(Arrays.equals(cacheKey1, cacheKey2));
+    Assertions.assertNotEquals(cacheKey1.length, 0);
+    Assertions.assertNotEquals(cacheKey2.length, 0);
+    Assertions.assertFalse(Arrays.equals(cacheKey1, cacheKey2));
   }
 
   @Test
@@ -457,9 +458,9 @@ public class JoinDataSourceTest
     byte[] cacheKey1 = joinDataSource.getCacheKey();
     byte[] cacheKey2 = joinDataSource1.getCacheKey();
 
-    Assert.assertNotEquals(cacheKey1.length, 0);
-    Assert.assertNotEquals(cacheKey2.length, 0);
-    Assert.assertFalse(Arrays.equals(cacheKey1, cacheKey2));
+    Assertions.assertNotEquals(cacheKey1.length, 0);
+    Assertions.assertNotEquals(cacheKey2.length, 0);
+    Assertions.assertFalse(Arrays.equals(cacheKey1, cacheKey2));
   }
 
   @Test
@@ -481,7 +482,7 @@ public class JoinDataSourceTest
         JoinAlgorithm.BROADCAST
     );
     JoinDataSourceAnalysis analysis = dataSource.getJoinAnalysisForDataSource();
-    Assert.assertEquals("table1", analysis.getBaseDataSource().getTableNames().iterator().next());
+    Assertions.assertEquals("table1", analysis.getBaseDataSource().getTableNames().iterator().next());
   }
 
   @Test
@@ -506,7 +507,7 @@ public class JoinDataSourceTest
         JoinAlgorithm.BROADCAST
     );
     JoinDataSourceAnalysis analysis = dataSource.getJoinAnalysisForDataSource();
-    Assert.assertEquals("table1", analysis.getBaseDataSource().getTableNames().iterator().next());
+    Assertions.assertEquals("table1", analysis.getBaseDataSource().getTableNames().iterator().next());
   }
 
   @Test
@@ -528,8 +529,8 @@ public class JoinDataSourceTest
         JoinAlgorithm.BROADCAST
     );
     JoinDataSourceAnalysis analysis = dataSource.getJoinAnalysisForDataSource();
-    Assert.assertEquals(left, analysis.getBaseDataSource());
-    Assert.assertEquals("table1", analysis.getBaseDataSource().getTableNames().iterator().next());
+    Assertions.assertEquals(left, analysis.getBaseDataSource());
+    Assertions.assertEquals("table1", analysis.getBaseDataSource().getTableNames().iterator().next());
   }
 
   @Test
@@ -565,9 +566,9 @@ public class JoinDataSourceTest
     byte[] cacheKey1 = joinDataSource.getCacheKey();
     byte[] cacheKey2 = joinDataSource1.getCacheKey();
 
-    Assert.assertNotEquals(cacheKey1.length, 0);
-    Assert.assertNotEquals(cacheKey2.length, 0);
-    Assert.assertFalse(Arrays.equals(cacheKey1, cacheKey2));
+    Assertions.assertNotEquals(cacheKey1.length, 0);
+    Assertions.assertNotEquals(cacheKey2.length, 0);
+    Assertions.assertFalse(Arrays.equals(cacheKey1, cacheKey2));
   }
 
   @Test
@@ -588,7 +589,7 @@ public class JoinDataSourceTest
     );
 
     byte[] cacheKey1 = joinDataSource.getCacheKey();
-    Assert.assertNull(cacheKey1);
+    Assertions.assertNull(cacheKey1);
   }
 
   private static class JoinableFactoryWithCacheKey extends NoopJoinableFactory
diff --git a/processing/src/test/java/org/apache/druid/query/MultiValuedDimensionTest.java b/processing/src/test/java/org/apache/druid/query/MultiValuedDimensionTest.java
index edd9f9a3145..8a9402312a5 100644
--- a/processing/src/test/java/org/apache/druid/query/MultiValuedDimensionTest.java
+++ b/processing/src/test/java/org/apache/druid/query/MultiValuedDimensionTest.java
@@ -73,13 +73,12 @@ import org.apache.druid.segment.writeout.SegmentWriteOutMediumFactory;
 import org.apache.druid.segment.writeout.TmpFileSegmentWriteOutMediumFactory;
 import org.apache.druid.testing.InitializedNullHandlingTest;
 import org.apache.druid.timeline.SegmentId;
-import org.junit.After;
-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.runners.Parameterized;
+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.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import java.io.File;
 import java.io.IOException;
@@ -94,10 +93,10 @@ import java.util.Map;
 
 /**
  */
-@RunWith(Parameterized.class)
+@ParameterizedClass
+@MethodSource("constructorFeeder")
 public class MultiValuedDimensionTest extends InitializedNullHandlingTest
 {
-  @Parameterized.Parameters(name = "groupby: {0} forceHashAggregation: {2} ({1})")
   public static Collection<?> constructorFeeder()
   {
     final List<Object[]> constructors = new ArrayList<>();
@@ -124,12 +123,9 @@ public class MultiValuedDimensionTest extends InitializedNullHandlingTest
   private final GroupByQueryConfig config;
   private final ImmutableMap<String, Object> context;
 
-  @Rule
-  public ExpectedException expectedException = ExpectedException.none();
-
   public MultiValuedDimensionTest(final GroupByQueryConfig config, SegmentWriteOutMediumFactory segmentWriteOutMediumFactory, boolean forceHashAggregation)
   {
-    helper = AggregationTestHelper.createGroupByQueryAggregationTestHelper(
+    helper = AggregationTestHelper.createGroupByQueryAggregationTestHelperWithTemporaryFolderExtension(
         ImmutableList.of(),
         config,
         null
@@ -140,7 +136,7 @@ public class MultiValuedDimensionTest extends InitializedNullHandlingTest
     this.context = ImmutableMap.of("forceHashAggregation", forceHashAggregation);
   }
 
-  @Before
+  @BeforeEach
   public void setup() throws Exception
   {
     incrementalIndex = new OnheapIncrementalIndex.Builder()
@@ -221,7 +217,7 @@ public class MultiValuedDimensionTest extends InitializedNullHandlingTest
     queryableIndexNullSampler = TestHelper.getTestIndexIO().loadIndex(persistedSegmentDirNullSampler);
   }
 
-  @After
+  @AfterEach
   public void teardown() throws IOException
   {
     helper.close();
@@ -953,11 +949,7 @@ public class MultiValuedDimensionTest extends InitializedNullHandlingTest
   @Test
   public void testGroupByExpressionMultiConflicting()
   {
-    expectedException.expect(RuntimeException.class);
-    expectedException.expectMessage(
-        "Invalid expression: (concat [(cartesian_map ([x, othertags] -> (concat [x, othertags])), [tags, othertags]), tags]); [tags] used as both scalar and array variables"
-    );
-    GroupByQuery query = GroupByQuery
+    final GroupByQuery query = GroupByQuery
         .builder()
         .setDataSource("xx")
         .setQuerySegmentSpec(new LegacySegmentSpec("1970/3000"))
@@ -976,23 +968,28 @@ public class MultiValuedDimensionTest extends InitializedNullHandlingTest
         .setContext(context)
         .build();
 
-    helper.runQueryOnSegmentsObjs(
-        ImmutableList.of(
-            new QueryableIndexSegment(queryableIndex, SegmentId.dummy("sid1")),
-            new IncrementalIndexSegment(incrementalIndex, SegmentId.dummy("sid2"))
-        ),
-        query
-    ).toList();
+    final RuntimeException exception = Assertions.assertThrows(
+        RuntimeException.class,
+        () -> helper.runQueryOnSegmentsObjs(
+            ImmutableList.of(
+                new QueryableIndexSegment(queryableIndex, SegmentId.dummy("sid1")),
+                new IncrementalIndexSegment(incrementalIndex, SegmentId.dummy("sid2"))
+            ),
+            query
+        ).toList()
+    );
+    Assertions.assertTrue(
+        exception.getMessage().contains(
+            "Invalid expression: (concat [(cartesian_map ([x, othertags] -> (concat [x, othertags])), [tags, othertags]), tags]);"
+            + " [tags] used as both scalar and array variables"
+        )
+    );
   }
 
   @Test
   public void testGroupByExpressionMultiConflictingAlso()
   {
-    expectedException.expect(RuntimeException.class);
-    expectedException.expectMessage(
-        "Invalid expression: (array_concat [tags, (array_append [othertags, tags])]); [tags] used as both scalar and array variables"
-    );
-    GroupByQuery query = GroupByQuery
+    final GroupByQuery query = GroupByQuery
         .builder()
         .setDataSource("xx")
         .setQuerySegmentSpec(new LegacySegmentSpec("1970/3000"))
@@ -1011,13 +1008,22 @@ public class MultiValuedDimensionTest extends InitializedNullHandlingTest
         .setContext(context)
         .build();
 
-    helper.runQueryOnSegmentsObjs(
-        ImmutableList.of(
-            new QueryableIndexSegment(queryableIndex, SegmentId.dummy("sid1")),
-            new IncrementalIndexSegment(incrementalIndex, SegmentId.dummy("sid2"))
-        ),
-        query
-    ).toList();
+    final RuntimeException exception = Assertions.assertThrows(
+        RuntimeException.class,
+        () -> helper.runQueryOnSegmentsObjs(
+            ImmutableList.of(
+                new QueryableIndexSegment(queryableIndex, SegmentId.dummy("sid1")),
+                new IncrementalIndexSegment(incrementalIndex, SegmentId.dummy("sid2"))
+            ),
+            query
+        ).toList()
+    );
+    Assertions.assertTrue(
+        exception.getMessage().contains(
+            "Invalid expression: (array_concat [tags, (array_append [othertags, tags])]);"
+            + " [tags] used as both scalar and array variables"
+        )
+    );
   }
 
   @Test
@@ -1187,7 +1193,7 @@ public class MultiValuedDimensionTest extends InitializedNullHandlingTest
     }
   }
 
-  @After
+  @AfterEach
   public void cleanup() throws Exception
   {
     queryableIndex.close();
diff --git a/processing/src/test/java/org/apache/druid/query/PrioritizedExecutorServiceTest.java b/processing/src/test/java/org/apache/druid/query/PrioritizedExecutorServiceTest.java
index 34a665829ef..17697589b42 100644
--- a/processing/src/test/java/org/apache/druid/query/PrioritizedExecutorServiceTest.java
+++ b/processing/src/test/java/org/apache/druid/query/PrioritizedExecutorServiceTest.java
@@ -23,14 +23,14 @@ import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Lists;
 import com.google.common.util.concurrent.ListenableFuture;
 import org.apache.druid.java.util.common.lifecycle.Lifecycle;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Assume;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.internal.AssumptionViolatedException;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Assumptions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.opentest4j.TestAbortedException;
 
 import java.util.List;
 import java.util.Random;
@@ -43,7 +43,8 @@ import java.util.concurrent.atomic.AtomicInteger;
 /**
  *
  */
-@RunWith(Parameterized.class)
+@ParameterizedClass
+@MethodSource("constructorFeeder")
 public class PrioritizedExecutorServiceTest
 {
   private PrioritizedExecutorService exec;
@@ -52,7 +53,6 @@ public class PrioritizedExecutorServiceTest
   private final boolean useFifo;
   private final DruidProcessingConfig config;
 
-  @Parameterized.Parameters(name = "{0}")
   public static Iterable<Object[]> constructorFeeder()
   {
     return ImmutableList.of(new Object[]{true}, new Object[]{false});
@@ -77,7 +77,7 @@ public class PrioritizedExecutorServiceTest
     };
   }
 
-  @Before
+  @BeforeEach
   public void setUp()
   {
     exec = PrioritizedExecutorService.create(
@@ -108,7 +108,7 @@ public class PrioritizedExecutorServiceTest
     finishLatch = new CountDownLatch(3);
   }
 
-  @After
+  @AfterEach
   public void tearDown()
   {
     exec.shutdownNow();
@@ -177,10 +177,10 @@ public class PrioritizedExecutorServiceTest
     latch.countDown();
     finishLatch.await();
 
-    Assert.assertTrue(order.size() == 3);
+    Assertions.assertTrue(order.size() == 3);
 
     List<Integer> expected = ImmutableList.of(2, 0, -1);
-    Assert.assertEquals(expected, ImmutableList.copyOf(order));
+    Assertions.assertEquals(expected, ImmutableList.copyOf(order));
   }
 
   @Test
@@ -188,10 +188,10 @@ public class PrioritizedExecutorServiceTest
   {
     final CountDownLatch latch = new CountDownLatch(1);
 
-    Assert.assertThrows(
-        "Class does not implemented PrioritizedRunnable",
+    Assertions.assertThrows(
         IllegalArgumentException.class,
-        () -> exec.execute(latch::countDown)
+        () -> exec.execute(latch::countDown),
+        "Class does not implemented PrioritizedRunnable"
     );
   }
 
@@ -268,7 +268,7 @@ public class PrioritizedExecutorServiceTest
           futures.add(exec.submit(getCheckingRunnable(i, hasRun)));
           break;
         default:
-          Assert.fail("Bad random result");
+          Assertions.fail("Bad random result");
       }
     }
     latch.countDown();
@@ -327,7 +327,7 @@ public class PrioritizedExecutorServiceTest
         future.get();
       }
       catch (ExecutionException e) {
-        if (!(e.getCause() instanceof AssumptionViolatedException)) {
+        if (!(e.getCause() instanceof TestAbortedException)) {
           throw e;
         }
       }
@@ -394,9 +394,9 @@ public class PrioritizedExecutorServiceTest
           throw new RuntimeException(e);
         }
         if (useFifo) {
-          Assert.assertEquals(myOrder, hasRun.getAndIncrement());
+          Assertions.assertEquals(myOrder, hasRun.getAndIncrement());
         } else {
-          Assume.assumeTrue(Integer.compare(myOrder, hasRun.getAndIncrement()) == 0);
+          Assumptions.assumeTrue(Integer.compare(myOrder, hasRun.getAndIncrement()) == 0);
         }
       }
     };
diff --git a/processing/src/test/java/org/apache/druid/query/QueriesTest.java b/processing/src/test/java/org/apache/druid/query/QueriesTest.java
index 2af7407f34e..7f968c573d0 100644
--- a/processing/src/test/java/org/apache/druid/query/QueriesTest.java
+++ b/processing/src/test/java/org/apache/druid/query/QueriesTest.java
@@ -37,8 +37,8 @@ import org.apache.druid.query.planning.ExecutionVertexTest;
 import org.apache.druid.query.spec.MultipleSpecificSegmentSpec;
 import org.apache.druid.query.timeseries.TimeseriesQuery;
 import org.apache.druid.segment.join.JoinType;
-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.Collections;
@@ -81,7 +81,7 @@ public class QueriesTest
       exceptionOccurred = true;
     }
 
-    Assert.assertFalse(exceptionOccurred);
+    Assertions.assertFalse(exceptionOccurred);
   }
 
   @Test
@@ -113,7 +113,7 @@ public class QueriesTest
       exceptionOccurred = true;
     }
 
-    Assert.assertTrue(exceptionOccurred);
+    Assertions.assertTrue(exceptionOccurred);
   }
 
   @Test
@@ -167,7 +167,7 @@ public class QueriesTest
       exceptionOccurred = true;
     }
 
-    Assert.assertFalse(exceptionOccurred);
+    Assertions.assertFalse(exceptionOccurred);
   }
 
   @Test
@@ -221,7 +221,7 @@ public class QueriesTest
       exceptionOccurred = true;
     }
 
-    Assert.assertTrue(exceptionOccurred);
+    Assertions.assertTrue(exceptionOccurred);
   }
 
   @Test
@@ -232,7 +232,7 @@ public class QueriesTest
         new SegmentDescriptor(Intervals.of("2000/3000"), "0", 1)
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         Druids.newTimeseriesQueryBuilder()
               .dataSource("foo")
               .intervals(
@@ -264,7 +264,7 @@ public class QueriesTest
         new SegmentDescriptor(Intervals.of("2000/3000"), "0", 1)
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         Druids.newTimeseriesQueryBuilder()
               .dataSource(
                   new QueryDataSource(
@@ -332,13 +332,13 @@ public class QueriesTest
         DruidException.class,
         () -> Queries.withSpecificSegments(query, descriptors)
     );
-    Assert.assertEquals("Base dataSource[LookupDataSource{lookupName='lookyloo'}] is not a table!", e.getMessage());
+    Assertions.assertEquals("Base dataSource[LookupDataSource{lookupName='lookyloo'}] is not a table!", e.getMessage());
   }
 
   @Test
   public void testWithBaseDataSourceBasic()
   {
-    Assert.assertEquals(
+    Assertions.assertEquals(
         Druids.newTimeseriesQueryBuilder()
               .dataSource("bar")
               .intervals("2000/3000")
@@ -358,7 +358,7 @@ public class QueriesTest
   @Test
   public void testWithBaseDataSourceSubQueryStackWithJoinOnUnion()
   {
-    Assert.assertEquals(
+    Assertions.assertEquals(
         Druids.newTimeseriesQueryBuilder()
             .dataSource(
                 JoinDataSource.create(
@@ -407,7 +407,7 @@ public class QueriesTest
   @Test
   public void testWithBaseDataSourcedBaseFilterWithMultiJoin()
   {
-    Assert.assertEquals(
+    Assertions.assertEquals(
         Druids.newTimeseriesQueryBuilder()
             .dataSource(
                 JoinDataSource.create(
diff --git a/processing/src/test/java/org/apache/druid/query/QueryContextTest.java b/processing/src/test/java/org/apache/druid/query/QueryContextTest.java
index d5550bc28dc..51a9ef8cadb 100644
--- a/processing/src/test/java/org/apache/druid/query/QueryContextTest.java
+++ b/processing/src/test/java/org/apache/druid/query/QueryContextTest.java
@@ -38,7 +38,7 @@ import org.apache.druid.segment.DimensionHandlerUtils;
 import org.joda.time.DateTimeZone;
 import org.joda.time.Duration;
 import org.joda.time.Interval;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import javax.annotation.Nullable;
 
@@ -47,12 +47,12 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertThrows;
-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.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class QueryContextTest
 {
diff --git a/processing/src/test/java/org/apache/druid/query/ResultGranularTimestampComparatorTest.java b/processing/src/test/java/org/apache/druid/query/ResultGranularTimestampComparatorTest.java
index 08c1d5f4388..d730d9212da 100644
--- a/processing/src/test/java/org/apache/druid/query/ResultGranularTimestampComparatorTest.java
+++ b/processing/src/test/java/org/apache/druid/query/ResultGranularTimestampComparatorTest.java
@@ -23,19 +23,19 @@ import org.apache.druid.java.util.common.DateTimes;
 import org.apache.druid.java.util.common.granularity.Granularities;
 import org.apache.druid.java.util.common.granularity.Granularity;
 import org.joda.time.DateTime;
-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.Test;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import java.util.Arrays;
 
 /**
  */
-@RunWith(Parameterized.class)
+@ParameterizedClass
+@MethodSource("constructorFeeder")
 public class ResultGranularTimestampComparatorTest
 {
-  @Parameterized.Parameters(name = "descending={0}")
   public static Iterable<Object[]> constructorFeeder()
   {
     return QueryRunnerTestHelper.transformToConstructionFeeder(Arrays.asList(false, true));
@@ -56,7 +56,7 @@ public class ResultGranularTimestampComparatorTest
     Result<Object> r1 = new Result<>(time, null);
     Result<Object> r2 = new Result<>(time.plusYears(5), null);
 
-    Assert.assertEquals(ResultGranularTimestampComparator.create(Granularities.ALL, descending).compare(r1, r2), 0);
+    Assertions.assertEquals(ResultGranularTimestampComparator.create(Granularities.ALL, descending).compare(r1, r2), 0);
   }
 
   @Test
@@ -68,9 +68,9 @@ public class ResultGranularTimestampComparatorTest
     Result<Object> less = new Result<>(time.minusHours(1), null);
 
     Granularity day = Granularities.DAY;
-    Assert.assertEquals(ResultGranularTimestampComparator.create(day, descending).compare(res, same), 0);
-    Assert.assertEquals(ResultGranularTimestampComparator.create(day, descending).compare(res, greater), descending ? 1 : -1);
-    Assert.assertEquals(ResultGranularTimestampComparator.create(day, descending).compare(res, less), descending ? -1 : 1);
+    Assertions.assertEquals(ResultGranularTimestampComparator.create(day, descending).compare(res, same), 0);
+    Assertions.assertEquals(ResultGranularTimestampComparator.create(day, descending).compare(res, greater), descending ? 1 : -1);
+    Assertions.assertEquals(ResultGranularTimestampComparator.create(day, descending).compare(res, less), descending ? -1 : 1);
   }
   
   @Test
@@ -82,8 +82,8 @@ public class ResultGranularTimestampComparatorTest
     Result<Object> less = new Result<>(time.minusHours(1), null);
 
     Granularity hour = Granularities.HOUR;
-    Assert.assertEquals(ResultGranularTimestampComparator.create(hour, descending).compare(res, same), 0);
-    Assert.assertEquals(ResultGranularTimestampComparator.create(hour, descending).compare(res, greater), descending ? 1 : -1);
-    Assert.assertEquals(ResultGranularTimestampComparator.create(hour, descending).compare(res, less), descending ? -1 : 1);
+    Assertions.assertEquals(ResultGranularTimestampComparator.create(hour, descending).compare(res, same), 0);
+    Assertions.assertEquals(ResultGranularTimestampComparator.create(hour, descending).compare(res, greater), descending ? 1 : -1);
+    Assertions.assertEquals(ResultGranularTimestampComparator.create(hour, descending).compare(res, less), descending ? -1 : 1);
   }
 }
diff --git a/processing/src/test/java/org/apache/druid/query/SchemaEvolutionTest.java b/processing/src/test/java/org/apache/druid/query/SchemaEvolutionTest.java
index 41850fdecf3..bfb1731f7c9 100644
--- a/processing/src/test/java/org/apache/druid/query/SchemaEvolutionTest.java
+++ b/processing/src/test/java/org/apache/druid/query/SchemaEvolutionTest.java
@@ -21,8 +21,6 @@ package org.apache.druid.query;
 
 import com.google.common.collect.Lists;
 import com.google.common.io.Closeables;
-import junitparams.JUnitParamsRunner;
-import junitparams.Parameters;
 import org.apache.druid.data.input.ColumnsFilter;
 import org.apache.druid.data.input.InputRow;
 import org.apache.druid.data.input.InputRowSchema;
@@ -51,14 +49,14 @@ import org.apache.druid.segment.QueryableIndex;
 import org.apache.druid.segment.QueryableIndexSegment;
 import org.apache.druid.segment.TestHelper;
 import org.apache.druid.segment.incremental.IncrementalIndexSchema;
+import org.apache.druid.testing.TemporaryFolderExtension;
 import org.apache.druid.timeline.SegmentId;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import java.io.IOException;
 import java.util.HashMap;
@@ -68,14 +66,13 @@ import java.util.Map;
 /**
  * Tests designed to exercise changing column types, adding columns, removing columns, etc.
  */
-@RunWith(JUnitParamsRunner.class)
 public class SchemaEvolutionTest
 {
   private static final String DATA_SOURCE = "foo";
   private static final String TIMESTAMP_COLUMN = "t";
   private static final double THIRTY_ONE_POINT_ONE = 31.1d;
 
-  public Object[] doVectorize()
+  public static Object[] doVectorize()
   {
     return Lists.newArrayList(true, false).toArray();
   }
@@ -127,8 +124,8 @@ public class SchemaEvolutionTest
     return results.toList();
   }
 
-  @Rule
-  public final TemporaryFolder temporaryFolder = new TemporaryFolder();
+  @RegisterExtension
+  public final TemporaryFolderExtension temporaryFolder = new TemporaryFolderExtension();
 
   // Index1: c1 is a string, c2 nonexistent, "uniques" nonexistent
   private QueryableIndex index1 = null;
@@ -142,7 +139,7 @@ public class SchemaEvolutionTest
   // Index4: c1 is nonexistent, c2 is uniques on c2
   private QueryableIndex index4 = null;
 
-  @Before
+  @BeforeEach
   public void setUp() throws IOException
   {
     // Index1: c1 is a string, c2 nonexistent, "uniques" nonexistent
@@ -208,7 +205,7 @@ public class SchemaEvolutionTest
     }
   }
 
-  @After
+  @AfterEach
   public void tearDown() throws IOException
   {
     Closeables.close(index1, false);
@@ -217,8 +214,8 @@ public class SchemaEvolutionTest
     Closeables.close(index4, false);
   }
 
-  @Test
-  @Parameters(method = "doVectorize")
+  @ParameterizedTest
+  @MethodSource("doVectorize")
   public void testHyperUniqueEvolutionTimeseries(boolean doVectorize)
   {
     final TimeseriesQueryRunnerFactory factory = QueryRunnerTestHelper.newTimeseriesQueryRunnerFactory();
@@ -236,20 +233,20 @@ public class SchemaEvolutionTest
         .build();
 
     // index1 has no "uniques" column
-    Assert.assertEquals(
+    Assertions.assertEquals(
         timeseriesResult(Map.of("uniques", 0d)),
         runQuery(query, factory, List.of(index1))
     );
 
     // index1 (no uniques) + index2 and index3 (yes uniques); we should be able to combine
-    Assert.assertEquals(
+    Assertions.assertEquals(
         timeseriesResult(Map.of("uniques", 4.003911343725148d)),
         runQuery(query, factory, List.of(index1, index2, index3))
     );
   }
 
-  @Test
-  @Parameters(method = "doVectorize")
+  @ParameterizedTest
+  @MethodSource("doVectorize")
   public void testNumericEvolutionTimeseriesAggregation(boolean doVectorize)
   {
     final TimeseriesQueryRunnerFactory factory = QueryRunnerTestHelper.newTimeseriesQueryRunnerFactory();
@@ -273,19 +270,19 @@ public class SchemaEvolutionTest
 
     // Only string(1)
     // Note: Expressions implicitly cast strings to numbers, leading to the a/b vs c/d difference.
-    Assert.assertEquals(
+    Assertions.assertEquals(
         timeseriesResult(Map.of("a", 31L, "b", THIRTY_ONE_POINT_ONE, "c", 31L, "d", THIRTY_ONE_POINT_ONE)),
         runQuery(query, factory, List.of(index1))
     );
 
     // Only long(2)
-    Assert.assertEquals(
+    Assertions.assertEquals(
         timeseriesResult(Map.of("a", 31L, "b", 31.0, "c", 31L, "d", 31.0)),
         runQuery(query, factory, List.of(index2))
     );
 
     // Only float(3)
-    Assert.assertEquals(
+    Assertions.assertEquals(
         timeseriesResult(Map.of("a", 31L, "b", THIRTY_ONE_POINT_ONE, "c", 31L, "d", THIRTY_ONE_POINT_ONE)),
         runQuery(query, factory, List.of(index3))
     );
@@ -296,14 +293,14 @@ public class SchemaEvolutionTest
     result.put("b", null);
     result.put("c", null);
     result.put("d", null);
-    Assert.assertEquals(
+    Assertions.assertEquals(
         timeseriesResult(result),
         runQuery(query, factory, List.of(index4))
     );
 
     // string(1) + long(2) + float(3) + nonexistent(4)
     // Note: Expressions implicitly cast strings to numbers, leading to the a/b vs c/d difference.
-    Assert.assertEquals(
+    Assertions.assertEquals(
         timeseriesResult(Map.of(
             "a", 31L * 3,
             "b", THIRTY_ONE_POINT_ONE * 2 + 31,
@@ -314,7 +311,7 @@ public class SchemaEvolutionTest
     );
 
     // long(2) + float(3) + nonexistent(4)
-    Assert.assertEquals(
+    Assertions.assertEquals(
         timeseriesResult(Map.of(
             "a", 31L * 2,
             "b", THIRTY_ONE_POINT_ONE + 31,
@@ -325,8 +322,8 @@ public class SchemaEvolutionTest
     );
   }
 
-  @Test
-  @Parameters(method = "doVectorize")
+  @ParameterizedTest
+  @MethodSource("doVectorize")
   public void testNumericEvolutionFiltering(boolean doVectorize)
   {
     final TimeseriesQueryRunnerFactory factory = QueryRunnerTestHelper.newTimeseriesQueryRunnerFactory();
@@ -351,25 +348,25 @@ public class SchemaEvolutionTest
         .build();
 
     // Only string(1) -- which we can filter but not aggregate
-    Assert.assertEquals(
+    Assertions.assertEquals(
         timeseriesResult(Map.of("a", 19L, "b", 19.1, "c", 2L, "d", 19.1f, "e", 9L)),
         runQuery(query, factory, List.of(index1))
     );
 
      // Only long(2) -- which we can filter and aggregate
-    Assert.assertEquals(
+    Assertions.assertEquals(
         timeseriesResult(Map.of("a", 19L, "b", 19.0, "c", 2L, "d", 19.0f, "e", 9L)),
         runQuery(query, factory, List.of(index2))
     );
 
     // Only float(3) -- which we can't filter, but can aggregate
-    Assert.assertEquals(
+    Assertions.assertEquals(
         timeseriesResult(Map.of("a", 19L, "b", 19.1, "c", 2L, "d", 19.1f, "e", 9L)),
         runQuery(query, factory, List.of(index3))
     );
 
     // Only nonexistent(4)
-    Assert.assertEquals(
+    Assertions.assertEquals(
         timeseriesResult(TestHelper.makeMap(
             "a",
             null,
@@ -386,7 +383,7 @@ public class SchemaEvolutionTest
     );
 
     // string(1) + long(2) + float(3) + nonexistent(4)
-    Assert.assertEquals(
+    Assertions.assertEquals(
         timeseriesResult(Map.of(
             "a", 57L,
             "b", 57.2,
diff --git a/processing/src/test/java/org/apache/druid/query/aggregation/AggregationTestHelper.java b/processing/src/test/java/org/apache/druid/query/aggregation/AggregationTestHelper.java
index 6ac02614b2c..2612727ad33 100644
--- a/processing/src/test/java/org/apache/druid/query/aggregation/AggregationTestHelper.java
+++ b/processing/src/test/java/org/apache/druid/query/aggregation/AggregationTestHelper.java
@@ -83,6 +83,7 @@ import org.apache.druid.segment.incremental.IncrementalIndex;
 import org.apache.druid.segment.incremental.IncrementalIndexSchema;
 import org.apache.druid.segment.incremental.OnheapIncrementalIndex;
 import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
+import org.apache.druid.testing.TemporaryFolderExtension;
 import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.utils.CloseableUtils;
 import org.junit.rules.TemporaryFolder;
@@ -167,6 +168,19 @@ public class AggregationTestHelper implements Closeable
     );
   }
 
+  public static AggregationTestHelper createGroupByQueryAggregationTestHelperWithTemporaryFolderExtension(
+      List<? extends Module> jsonModulesToRegister,
+      GroupByQueryConfig config,
+      TemporaryFolderExtension tempFolder
+  )
+  {
+    return createGroupByQueryAggregationTestHelper(
+        jsonModulesToRegister,
+        config,
+        tempFolderProvider(tempFolder)
+    );
+  }
+
   public static AggregationTestHelper createGroupByQueryAggregationTestHelperWithTempDir(
       List<? extends Module> jsonModulesToRegister,
       GroupByQueryConfig config,
@@ -229,6 +243,17 @@ public class AggregationTestHelper implements Closeable
     );
   }
 
+  public static AggregationTestHelper createTimeseriesQueryAggregationTestHelperWithTemporaryFolderExtension(
+      List<? extends Module> jsonModulesToRegister,
+      TemporaryFolderExtension tempFolder
+  )
+  {
+    return createTimeseriesQueryAggregationTestHelper(
+        jsonModulesToRegister,
+        tempFolderProvider(tempFolder)
+    );
+  }
+
   public static AggregationTestHelper createTimeseriesQueryAggregationTestHelperWithTempDir(
       List<? extends Module> jsonModulesToRegister,
       File tempFolder
@@ -286,6 +311,17 @@ public class AggregationTestHelper implements Closeable
     );
   }
 
+  public static AggregationTestHelper createTopNQueryAggregationTestHelperWithTemporaryFolderExtension(
+      List<? extends Module> jsonModulesToRegister,
+      TemporaryFolderExtension tempFolder
+  )
+  {
+    return createTopNQueryAggregationTestHelper(
+        jsonModulesToRegister,
+        tempFolderProvider(tempFolder)
+    );
+  }
+
   public static AggregationTestHelper createTopNQueryAggregationTestHelperWithTempDir(
       List<? extends Module> jsonModulesToRegister,
       File tempFolder
@@ -355,6 +391,17 @@ public class AggregationTestHelper implements Closeable
     );
   }
 
+  public static AggregationTestHelper createScanQueryAggregationTestHelperWithTemporaryFolderExtension(
+      List<? extends Module> jsonModulesToRegister,
+      TemporaryFolderExtension tempFolder
+  )
+  {
+    return createScanQueryAggregationTestHelper(
+        jsonModulesToRegister,
+        tempFolderProvider(tempFolder)
+    );
+  }
+
   public static AggregationTestHelper createScanQueryAggregationTestHelperWithTempDir(
       List<? extends Module> jsonModulesToRegister,
       File tempFolder
@@ -404,6 +451,11 @@ public class AggregationTestHelper implements Closeable
     );
   }
 
+  private static TempFolderProvider tempFolderProvider(final TemporaryFolderExtension tempFolder)
+  {
+    return () -> tempFolder.newFolder();
+  }
+
   private static TempFolderProvider tempFolderProvider(final TemporaryFolder tempFolder)
   {
     return () -> tempFolder.newFolder();
diff --git a/processing/src/test/java/org/apache/druid/query/aggregation/ExpressionLambdaAggregationTest.java b/processing/src/test/java/org/apache/druid/query/aggregation/ExpressionLambdaAggregationTest.java
index baef2de3a0a..be7831234ac 100644
--- a/processing/src/test/java/org/apache/druid/query/aggregation/ExpressionLambdaAggregationTest.java
+++ b/processing/src/test/java/org/apache/druid/query/aggregation/ExpressionLambdaAggregationTest.java
@@ -41,14 +41,14 @@ import org.apache.druid.segment.QueryableIndexSegment;
 import org.apache.druid.segment.Segment;
 import org.apache.druid.segment.incremental.IncrementalIndexSchema;
 import org.apache.druid.testing.InitializedNullHandlingTest;
+import org.apache.druid.testing.TemporaryFolderExtension;
 import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.utils.CloseableUtils;
 import org.joda.time.DateTime;
-import org.junit.After;
-import org.junit.Assert;
-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.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
 
 import java.util.Collections;
 import java.util.List;
@@ -65,13 +65,13 @@ public class ExpressionLambdaAggregationTest extends InitializedNullHandlingTest
   private static final String DOUBLE_FIELD = "doubleField";
   private static final DateTime TIMESTAMP = DateTimes.of("2020-01-01");
 
-  @Rule
-  public final TemporaryFolder tempFolder = new TemporaryFolder();
+  @RegisterExtension
+  public final TemporaryFolderExtension tempFolder = new TemporaryFolderExtension();
 
   private QueryableIndex mergedIndex;
   private Segment segment;
 
-  @After
+  @AfterEach
   public void tearDown()
   {
     if (segment != null) {
@@ -184,7 +184,10 @@ public class ExpressionLambdaAggregationTest extends InitializedNullHandlingTest
                                         .build();
 
     try (final AggregationTestHelper helper =
-             AggregationTestHelper.createTimeseriesQueryAggregationTestHelper(Collections.emptyList(), tempFolder)) {
+             AggregationTestHelper.createTimeseriesQueryAggregationTestHelperWithTemporaryFolderExtension(
+                 Collections.emptyList(),
+                 tempFolder
+             )) {
 
       final Sequence<Result<TimeseriesResultValue>> seq = helper.runQueryOnSegmentsObjs(
           ImmutableList.of(segment),
@@ -193,10 +196,10 @@ public class ExpressionLambdaAggregationTest extends InitializedNullHandlingTest
       final TimeseriesResultValue result = Iterables.getOnlyElement(seq.toList()).getValue();
 
       // Three input rows rolled up into one, count reflects rollup happened
-      Assert.assertEquals(3L, result.getLongMetric("count").longValue());
-      Assert.assertEquals(7L, result.getLongMetric("long_sum").longValue());
-      Assert.assertEquals(7L, result.getLongMetric("bitwise_or").longValue());
-      Assert.assertEquals(3.75, result.getDoubleMetric("double_sum").doubleValue(), 0.0);
+      Assertions.assertEquals(3L, result.getLongMetric("count").longValue());
+      Assertions.assertEquals(7L, result.getLongMetric("long_sum").longValue());
+      Assertions.assertEquals(7L, result.getLongMetric("bitwise_or").longValue());
+      Assertions.assertEquals(3.75, result.getDoubleMetric("double_sum").doubleValue(), 0.0);
     }
   }
 
diff --git a/processing/src/test/java/org/apache/druid/query/aggregation/ExpressionLambdaAggregatorFactoryTest.java b/processing/src/test/java/org/apache/druid/query/aggregation/ExpressionLambdaAggregatorFactoryTest.java
index 29bf850d3d4..7b041c725fd 100644
--- a/processing/src/test/java/org/apache/druid/query/aggregation/ExpressionLambdaAggregatorFactoryTest.java
+++ b/processing/src/test/java/org/apache/druid/query/aggregation/ExpressionLambdaAggregatorFactoryTest.java
@@ -40,22 +40,18 @@ import org.apache.druid.segment.column.ColumnType;
 import org.apache.druid.segment.column.RowSignature;
 import org.apache.druid.segment.selector.TestColumnValueSelector;
 import org.apache.druid.testing.InitializedNullHandlingTest;
-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.Test;
 
 import javax.annotation.Nullable;
+
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.List;
 
 public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandlingTest
 {
-  private static ObjectMapper MAPPER = TestHelper.makeJsonMapper();
-
-  @Rule
-  public ExpectedException expectedException = ExpectedException.none();
+  private static final ObjectMapper MAPPER = TestHelper.makeJsonMapper();
 
   @Test
   public void testSerde() throws IOException
@@ -77,7 +73,7 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
         TestExprMacroTable.INSTANCE
     );
 
-    Assert.assertEquals(agg, MAPPER.readValue(MAPPER.writeValueAsBytes(agg), ExpressionLambdaAggregatorFactory.class));
+    Assertions.assertEquals(agg, MAPPER.readValue(MAPPER.writeValueAsBytes(agg), ExpressionLambdaAggregatorFactory.class));
   }
 
   @Test
@@ -104,10 +100,7 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
   @Test
   public void testInitialValueMustBeConstant()
   {
-    expectedException.expect(IllegalArgumentException.class);
-    expectedException.expectMessage("initial value must be constant");
-
-    ExpressionLambdaAggregatorFactory agg = new ExpressionLambdaAggregatorFactory(
+    final ExpressionLambdaAggregatorFactory agg = new ExpressionLambdaAggregatorFactory(
         "expr_agg_name",
         ImmutableSet.of("some_column", "some_other_column"),
         null,
@@ -124,16 +117,17 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
         TestExprMacroTable.INSTANCE
     );
 
-    agg.getIntermediateType();
+    final IllegalArgumentException exception = Assertions.assertThrows(
+        IllegalArgumentException.class,
+        agg::getIntermediateType
+    );
+    Assertions.assertTrue(exception.getMessage().contains("initial value must be constant"));
   }
 
   @Test
   public void testInitialCombineValueMustBeConstant()
   {
-    expectedException.expect(IllegalArgumentException.class);
-    expectedException.expectMessage("initial combining value must be constant");
-
-    ExpressionLambdaAggregatorFactory agg = new ExpressionLambdaAggregatorFactory(
+    final ExpressionLambdaAggregatorFactory agg = new ExpressionLambdaAggregatorFactory(
         "expr_agg_name",
         ImmutableSet.of("some_column", "some_other_column"),
         null,
@@ -150,7 +144,11 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
         TestExprMacroTable.INSTANCE
     );
 
-    agg.getResultType();
+    final IllegalArgumentException exception = Assertions.assertThrows(
+        IllegalArgumentException.class,
+        agg::getResultType
+    );
+    Assertions.assertTrue(exception.getMessage().contains("initial combining value must be constant"));
   }
 
   @Test
@@ -173,7 +171,7 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
         TestExprMacroTable.INSTANCE
     );
 
-    Assert.assertEquals(1L, agg.combine(0L, 1L));
+    Assertions.assertEquals(1L, agg.combine(0L, 1L));
   }
 
   @Test
@@ -196,8 +194,8 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
         TestExprMacroTable.INSTANCE
     );
 
-    Assert.assertArrayEquals(new Object[]{"hello"}, (Object[]) agg.combine(null, new Object[]{"hello"}));
-    Assert.assertArrayEquals(
+    Assertions.assertArrayEquals(new Object[]{"hello"}, (Object[]) agg.combine(null, new Object[]{"hello"}));
+    Assertions.assertArrayEquals(
         new Object[]{"hello", "world"},
         (Object[]) agg.combine(new Object[]{"hello"}, new Object[]{"world"})
     );
@@ -223,8 +221,8 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
         TestExprMacroTable.INSTANCE
     );
 
-    Assert.assertNull(agg.combine(null, new Object[]{"hello"}));
-    Assert.assertArrayEquals(
+    Assertions.assertNull(agg.combine(null, new Object[]{"hello"}));
+    Assertions.assertArrayEquals(
         new Object[]{"hello", "world"},
         (Object[]) agg.combine(new Object[]{"hello"}, new Object[]{"world"})
     );
@@ -250,7 +248,7 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
         TestExprMacroTable.INSTANCE
     );
 
-    Assert.assertEquals(100L, agg.finalizeComputation(0L));
+    Assertions.assertEquals(100L, agg.finalizeComputation(0L));
   }
 
   @Test
@@ -273,8 +271,8 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
         TestExprMacroTable.INSTANCE
     );
 
-    Assert.assertEquals("a,b,c", agg.finalizeComputation(new String[]{"a", "b", "c"}));
-    Assert.assertEquals("a,b,c", agg.finalizeComputation(ImmutableList.of("a", "b", "c")));
+    Assertions.assertEquals("a,b,c", agg.finalizeComputation(new String[]{"a", "b", "c"}));
+    Assertions.assertEquals("a,b,c", agg.finalizeComputation(ImmutableList.of("a", "b", "c")));
   }
 
   @Test
@@ -297,9 +295,9 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
         TestExprMacroTable.INSTANCE
     );
 
-    Assert.assertEquals(ColumnType.STRING, agg.getIntermediateType());
-    Assert.assertEquals(ColumnType.STRING, agg.getCombiningFactory().getIntermediateType());
-    Assert.assertEquals(ColumnType.STRING, agg.getResultType());
+    Assertions.assertEquals(ColumnType.STRING, agg.getIntermediateType());
+    Assertions.assertEquals(ColumnType.STRING, agg.getCombiningFactory().getIntermediateType());
+    Assertions.assertEquals(ColumnType.STRING, agg.getResultType());
   }
 
   @Test
@@ -322,9 +320,9 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
         TestExprMacroTable.INSTANCE
     );
 
-    Assert.assertEquals(ColumnType.LONG, agg.getIntermediateType());
-    Assert.assertEquals(ColumnType.LONG, agg.getCombiningFactory().getIntermediateType());
-    Assert.assertEquals(ColumnType.LONG, agg.getResultType());
+    Assertions.assertEquals(ColumnType.LONG, agg.getIntermediateType());
+    Assertions.assertEquals(ColumnType.LONG, agg.getCombiningFactory().getIntermediateType());
+    Assertions.assertEquals(ColumnType.LONG, agg.getResultType());
   }
 
   @Test
@@ -347,9 +345,9 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
         TestExprMacroTable.INSTANCE
     );
 
-    Assert.assertEquals(ColumnType.DOUBLE, agg.getIntermediateType());
-    Assert.assertEquals(ColumnType.DOUBLE, agg.getCombiningFactory().getIntermediateType());
-    Assert.assertEquals(ColumnType.DOUBLE, agg.getResultType());
+    Assertions.assertEquals(ColumnType.DOUBLE, agg.getIntermediateType());
+    Assertions.assertEquals(ColumnType.DOUBLE, agg.getCombiningFactory().getIntermediateType());
+    Assertions.assertEquals(ColumnType.DOUBLE, agg.getResultType());
   }
 
   @Test
@@ -372,9 +370,9 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
         TestExprMacroTable.INSTANCE
     );
 
-    Assert.assertEquals(ColumnType.STRING, agg.getIntermediateType());
-    Assert.assertEquals(ColumnType.STRING_ARRAY, agg.getCombiningFactory().getIntermediateType());
-    Assert.assertEquals(ColumnType.STRING_ARRAY, agg.getResultType());
+    Assertions.assertEquals(ColumnType.STRING, agg.getIntermediateType());
+    Assertions.assertEquals(ColumnType.STRING_ARRAY, agg.getCombiningFactory().getIntermediateType());
+    Assertions.assertEquals(ColumnType.STRING_ARRAY, agg.getResultType());
   }
 
   @Test
@@ -397,9 +395,9 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
         TestExprMacroTable.INSTANCE
     );
 
-    Assert.assertEquals(ColumnType.STRING, agg.getIntermediateType());
-    Assert.assertEquals(ColumnType.STRING_ARRAY, agg.getCombiningFactory().getIntermediateType());
-    Assert.assertEquals(ColumnType.STRING, agg.getResultType());
+    Assertions.assertEquals(ColumnType.STRING, agg.getIntermediateType());
+    Assertions.assertEquals(ColumnType.STRING_ARRAY, agg.getCombiningFactory().getIntermediateType());
+    Assertions.assertEquals(ColumnType.STRING, agg.getResultType());
   }
 
   @Test
@@ -422,9 +420,9 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
         TestExprMacroTable.INSTANCE
     );
 
-    Assert.assertEquals(ColumnType.LONG, agg.getIntermediateType());
-    Assert.assertEquals(ColumnType.LONG_ARRAY, agg.getCombiningFactory().getIntermediateType());
-    Assert.assertEquals(ColumnType.LONG_ARRAY, agg.getResultType());
+    Assertions.assertEquals(ColumnType.LONG, agg.getIntermediateType());
+    Assertions.assertEquals(ColumnType.LONG_ARRAY, agg.getCombiningFactory().getIntermediateType());
+    Assertions.assertEquals(ColumnType.LONG_ARRAY, agg.getResultType());
   }
 
   @Test
@@ -447,9 +445,9 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
         TestExprMacroTable.INSTANCE
     );
 
-    Assert.assertEquals(ColumnType.LONG, agg.getIntermediateType());
-    Assert.assertEquals(ColumnType.LONG_ARRAY, agg.getCombiningFactory().getIntermediateType());
-    Assert.assertEquals(ColumnType.STRING, agg.getResultType());
+    Assertions.assertEquals(ColumnType.LONG, agg.getIntermediateType());
+    Assertions.assertEquals(ColumnType.LONG_ARRAY, agg.getCombiningFactory().getIntermediateType());
+    Assertions.assertEquals(ColumnType.STRING, agg.getResultType());
   }
 
   @Test
@@ -472,9 +470,9 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
         TestExprMacroTable.INSTANCE
     );
 
-    Assert.assertEquals(ColumnType.DOUBLE, agg.getIntermediateType());
-    Assert.assertEquals(ColumnType.DOUBLE_ARRAY, agg.getCombiningFactory().getIntermediateType());
-    Assert.assertEquals(ColumnType.DOUBLE_ARRAY, agg.getResultType());
+    Assertions.assertEquals(ColumnType.DOUBLE, agg.getIntermediateType());
+    Assertions.assertEquals(ColumnType.DOUBLE_ARRAY, agg.getCombiningFactory().getIntermediateType());
+    Assertions.assertEquals(ColumnType.DOUBLE_ARRAY, agg.getResultType());
   }
 
   @Test
@@ -497,9 +495,9 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
         TestExprMacroTable.INSTANCE
     );
 
-    Assert.assertEquals(ColumnType.DOUBLE, agg.getIntermediateType());
-    Assert.assertEquals(ColumnType.DOUBLE_ARRAY, agg.getCombiningFactory().getIntermediateType());
-    Assert.assertEquals(ColumnType.STRING, agg.getResultType());
+    Assertions.assertEquals(ColumnType.DOUBLE, agg.getIntermediateType());
+    Assertions.assertEquals(ColumnType.DOUBLE_ARRAY, agg.getCombiningFactory().getIntermediateType());
+    Assertions.assertEquals(ColumnType.STRING, agg.getResultType());
   }
 
   @Test
@@ -522,9 +520,9 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
         TestExprMacroTable.INSTANCE
     );
 
-    Assert.assertEquals(HyperUniquesAggregatorFactory.TYPE, agg.getIntermediateType());
-    Assert.assertEquals(HyperUniquesAggregatorFactory.TYPE, agg.getCombiningFactory().getIntermediateType());
-    Assert.assertEquals(HyperUniquesAggregatorFactory.TYPE, agg.getResultType());
+    Assertions.assertEquals(HyperUniquesAggregatorFactory.TYPE, agg.getIntermediateType());
+    Assertions.assertEquals(HyperUniquesAggregatorFactory.TYPE, agg.getCombiningFactory().getIntermediateType());
+    Assertions.assertEquals(HyperUniquesAggregatorFactory.TYPE, agg.getResultType());
   }
 
   @Test
@@ -547,9 +545,9 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
         TestExprMacroTable.INSTANCE
     );
 
-    Assert.assertEquals(HyperUniquesAggregatorFactory.TYPE, agg.getIntermediateType());
-    Assert.assertEquals(HyperUniquesAggregatorFactory.TYPE, agg.getCombiningFactory().getIntermediateType());
-    Assert.assertEquals(ColumnType.DOUBLE, agg.getResultType());
+    Assertions.assertEquals(HyperUniquesAggregatorFactory.TYPE, agg.getIntermediateType());
+    Assertions.assertEquals(HyperUniquesAggregatorFactory.TYPE, agg.getCombiningFactory().getIntermediateType());
+    Assertions.assertEquals(ColumnType.DOUBLE, agg.getResultType());
   }
 
   @Test
@@ -579,15 +577,15 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
     );
     selector.advance();
     combiner.reset(selector);
-    Assert.assertEquals(1L, combiner.getLong());
+    Assertions.assertEquals(1L, combiner.getLong());
 
     selector.advance();
     combiner.fold(selector);
-    Assert.assertEquals(3L, combiner.getLong());
+    Assertions.assertEquals(3L, combiner.getLong());
 
     selector.advance();
     combiner.fold(selector);
-    Assert.assertEquals(6L, combiner.getLong());
+    Assertions.assertEquals(6L, combiner.getLong());
   }
 
   @Test
@@ -617,15 +615,15 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
     );
     selector.advance();
     combiner.reset(selector);
-    Assert.assertEquals(1.5, combiner.getDouble(), 0.0);
+    Assertions.assertEquals(1.5, combiner.getDouble(), 0.0);
 
     selector.advance();
     combiner.fold(selector);
-    Assert.assertEquals(3.75, combiner.getDouble(), 0.0);
+    Assertions.assertEquals(3.75, combiner.getDouble(), 0.0);
 
     selector.advance();
     combiner.fold(selector);
-    Assert.assertEquals(4.0, combiner.getDouble(), 0.0);
+    Assertions.assertEquals(4.0, combiner.getDouble(), 0.0);
   }
 
   @Test
@@ -652,20 +650,20 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
     NullableLongSelector selector = new NullableLongSelector(Arrays.asList(null, 5L, null, 7L));
     selector.advance();
     combiner.reset(selector);
-    Assert.assertTrue(combiner.isNull());
+    Assertions.assertTrue(combiner.isNull());
 
     selector.advance();
     combiner.fold(selector);
-    Assert.assertFalse(combiner.isNull());
-    Assert.assertEquals(5L, combiner.getLong());
+    Assertions.assertFalse(combiner.isNull());
+    Assertions.assertEquals(5L, combiner.getLong());
 
     selector.advance();
     combiner.fold(selector);
-    Assert.assertEquals(5L, combiner.getLong());
+    Assertions.assertEquals(5L, combiner.getLong());
 
     selector.advance();
     combiner.fold(selector);
-    Assert.assertEquals(12L, combiner.getLong());
+    Assertions.assertEquals(12L, combiner.getLong());
   }
 
   @Test
@@ -694,16 +692,16 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
     NullableLongSelector selector = new NullableLongSelector(Arrays.asList(1L, null, 3L));
     selector.advance();
     combiner.reset(selector);
-    Assert.assertEquals(1L, combiner.getLong());
+    Assertions.assertEquals(1L, combiner.getLong());
 
     // null is passed through to the expression, which coalesces to 0
     selector.advance();
     combiner.fold(selector);
-    Assert.assertEquals(1L, combiner.getLong());
+    Assertions.assertEquals(1L, combiner.getLong());
 
     selector.advance();
     combiner.fold(selector);
-    Assert.assertEquals(4L, combiner.getLong());
+    Assertions.assertEquals(4L, combiner.getLong());
   }
 
   @Test
@@ -732,12 +730,12 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
     NullableLongSelector selector = new NullableLongSelector(Arrays.asList(1L, null));
     selector.advance();
     combiner.reset(selector);
-    Assert.assertFalse(combiner.isNull());
-    Assert.assertEquals(1L, combiner.getLong());
+    Assertions.assertFalse(combiner.isNull());
+    Assertions.assertEquals(1L, combiner.getLong());
 
     selector.advance();
     combiner.fold(selector);
-    Assert.assertTrue(combiner.isNull());
+    Assertions.assertTrue(combiner.isNull());
   }
 
 
@@ -800,7 +798,7 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
     }
   }
 
-  @Test(expected = UOE.class)
+  @Test
   public void testAggregateCombinerNotSupportedForNonNumericTypes()
   {
     ExpressionLambdaAggregatorFactory agg = new ExpressionLambdaAggregatorFactory(
@@ -820,10 +818,10 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
         TestExprMacroTable.INSTANCE
     );
 
-    agg.makeAggregateCombiner();
+    Assertions.assertThrows(UOE.class, agg::makeAggregateCombiner);
   }
 
-  @Test(expected = UOE.class)
+  @Test
   public void testAggregateCombinerNotSupportedWhenFoldAndCombineTypesDiffer()
   {
     // fold seed is LONG (intermediate column type), but combine seed is LONG_ARRAY — combining a long segment column
@@ -845,8 +843,8 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
         TestExprMacroTable.INSTANCE
     );
 
-    Assert.assertEquals(ColumnType.LONG, agg.getIntermediateType());
-    agg.makeAggregateCombiner();
+    Assertions.assertEquals(ColumnType.LONG, agg.getIntermediateType());
+    Assertions.assertThrows(UOE.class, agg::makeAggregateCombiner);
   }
 
   @Test
@@ -1047,7 +1045,7 @@ public class ExpressionLambdaAggregatorFactoryTest extends InitializedNullHandli
               )
               .build();
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         RowSignature.builder()
                     .addTimeColumn()
                     .add("string_expr", ColumnType.STRING)
diff --git a/processing/src/test/java/org/apache/druid/query/aggregation/FilteredAggregatorTest.java b/processing/src/test/java/org/apache/druid/query/aggregation/FilteredAggregatorTest.java
index 8495e3d67df..4f7e2f0c176 100644
--- a/processing/src/test/java/org/apache/druid/query/aggregation/FilteredAggregatorTest.java
+++ b/processing/src/test/java/org/apache/druid/query/aggregation/FilteredAggregatorTest.java
@@ -51,10 +51,11 @@ import org.apache.druid.segment.column.ColumnType;
 import org.apache.druid.segment.data.IndexedInts;
 import org.apache.druid.segment.data.SingleIndexedInt;
 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 javax.annotation.Nullable;
+
 import java.util.Arrays;
 
 public class FilteredAggregatorTest extends InitializedNullHandlingTest
@@ -406,17 +407,17 @@ public class FilteredAggregatorTest extends InitializedNullHandlingTest
     );
 
     // Validate state before any aggregation
-    Assert.assertTrue(agg.isNull());
-    Assert.assertNull(agg.get());
+    Assertions.assertTrue(agg.isNull());
+    Assertions.assertNull(agg.get());
 
     for (Float expectedValue : expectedValues) {
       aggregate(selector, agg);
       if (expectedValue == null) {
-        Assert.assertTrue(agg.isNull());
-        Assert.assertNull(agg.get());
+        Assertions.assertTrue(agg.isNull());
+        Assertions.assertNull(agg.get());
       } else {
-        Assert.assertFalse(agg.isNull());
-        Assert.assertEquals(expectedValue, agg.getFloat(), 0.001);
+        Assertions.assertFalse(agg.isNull());
+        Assertions.assertEquals(expectedValue, agg.getFloat(), 0.001);
       }
     }
   }
diff --git a/processing/src/test/java/org/apache/druid/query/aggregation/GroupingAggregatorFactoryTest.java b/processing/src/test/java/org/apache/druid/query/aggregation/GroupingAggregatorFactoryTest.java
index c9772ab9534..15c6fdd0767 100644
--- a/processing/src/test/java/org/apache/druid/query/aggregation/GroupingAggregatorFactoryTest.java
+++ b/processing/src/test/java/org/apache/druid/query/aggregation/GroupingAggregatorFactoryTest.java
@@ -20,20 +20,19 @@
 package org.apache.druid.query.aggregation;
 
 import com.google.common.collect.Sets;
-import junitparams.converters.Nullable;
 import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.query.aggregation.constant.LongConstantAggregator;
 import org.apache.druid.query.aggregation.constant.LongConstantBufferAggregator;
 import org.apache.druid.query.aggregation.constant.LongConstantVectorAggregator;
 import org.apache.druid.segment.ColumnSelectorFactory;
 import org.easymock.EasyMock;
-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.runners.Parameterized;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import javax.annotation.Nullable;
 
 import java.util.Arrays;
 import java.util.Collection;
@@ -53,7 +52,7 @@ public class GroupingAggregatorFactoryTest
   {
     private ColumnSelectorFactory metricFactory;
 
-    @Before
+    @BeforeEach
     public void setup()
     {
       metricFactory = EasyMock.mock(ColumnSelectorFactory.class);
@@ -64,8 +63,8 @@ public class GroupingAggregatorFactoryTest
     {
       GroupingAggregatorFactory factory = makeFactory(new String[]{"a", "b"}, new String[]{"a"});
       Aggregator aggregator = factory.factorize(metricFactory);
-      Assert.assertEquals(LongConstantAggregator.class, aggregator.getClass());
-      Assert.assertEquals(1, aggregator.getLong());
+      Assertions.assertEquals(LongConstantAggregator.class, aggregator.getClass());
+      Assertions.assertEquals(1, aggregator.getLong());
     }
 
     @Test
@@ -73,18 +72,18 @@ public class GroupingAggregatorFactoryTest
     {
       GroupingAggregatorFactory factory = makeFactory(new String[]{"a", "b"}, new String[]{"a"});
       BufferAggregator aggregator = factory.factorizeBuffered(metricFactory);
-      Assert.assertEquals(LongConstantBufferAggregator.class, aggregator.getClass());
-      Assert.assertEquals(1, aggregator.getLong(null, 0));
+      Assertions.assertEquals(LongConstantBufferAggregator.class, aggregator.getClass());
+      Assertions.assertEquals(1, aggregator.getLong(null, 0));
     }
 
     @Test
     public void testNewVectorAggregator()
     {
       GroupingAggregatorFactory factory = makeFactory(new String[]{"a", "b"}, new String[]{"a"});
-      Assert.assertTrue(factory.canVectorize(metricFactory));
+      Assertions.assertTrue(factory.canVectorize(metricFactory));
       VectorAggregator aggregator = factory.factorizeVector(null);
-      Assert.assertEquals(LongConstantVectorAggregator.class, aggregator.getClass());
-      Assert.assertEquals(1L, aggregator.get(null, 0));
+      Assertions.assertEquals(LongConstantVectorAggregator.class, aggregator.getClass());
+      Assertions.assertEquals(1L, aggregator.get(null, 0));
     }
 
     @Test
@@ -92,56 +91,67 @@ public class GroupingAggregatorFactoryTest
     {
       GroupingAggregatorFactory factory = makeFactory(new String[]{"a", "b"}, new String[]{"a"});
       Aggregator aggregator = factory.factorize(metricFactory);
-      Assert.assertEquals(1, aggregator.getLong());
+      Assertions.assertEquals(1, aggregator.getLong());
       factory = factory.withKeyDimensions(Sets.newHashSet("b"));
       aggregator = factory.factorize(metricFactory);
-      Assert.assertEquals(2, aggregator.getLong());
+      Assertions.assertEquals(2, aggregator.getLong());
     }
   }
 
   public static class GroupingDimensionsTest
   {
-    @Rule
-    public ExpectedException exception = ExpectedException.none();
-
     @Test
     public void testFactory_nullGroupingDimensions()
     {
-      exception.expect(IllegalArgumentException.class);
-      exception.expectMessage("Must have a non-empty grouping dimensions");
-      GroupingAggregatorFactory factory = new GroupingAggregatorFactory("name", null, Sets.newHashSet("b"));
+      final IllegalArgumentException exception = Assertions.assertThrows(
+          IllegalArgumentException.class,
+          () -> new GroupingAggregatorFactory("name", null, Sets.newHashSet("b"))
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Must have a non-empty grouping dimensions"));
     }
 
     @Test
     public void testFactory_emptyGroupingDimensions()
     {
-      exception.expect(IllegalArgumentException.class);
-      exception.expectMessage("Must have a non-empty grouping dimensions");
-      makeFactory(new String[0], null);
+      final IllegalArgumentException exception = Assertions.assertThrows(
+          IllegalArgumentException.class,
+          () -> makeFactory(new String[0], null)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Must have a non-empty grouping dimensions"));
     }
 
     @Test
     public void testFactory_highNumberOfGroupingDimensions()
     {
-      exception.expect(IllegalArgumentException.class);
-      exception.expectMessage(StringUtils.format(
-          "Number of dimensions %d is more than supported %d",
-          Long.SIZE,
-          Long.SIZE - 1
-      ));
-      makeFactory(new String[Long.SIZE], null);
+      final IllegalArgumentException exception = Assertions.assertThrows(
+          IllegalArgumentException.class,
+          () -> makeFactory(new String[Long.SIZE], null)
+      );
+      Assertions.assertTrue(
+          exception.getMessage().contains(StringUtils.format(
+              "Number of dimensions %d is more than supported %d",
+              Long.SIZE,
+              Long.SIZE - 1
+          ))
+      );
     }
 
     @Test
     public void testWithDuplicateGroupings()
     {
-      exception.expect(IllegalArgumentException.class);
-      exception.expectMessage("Encountered same dimension more than once in groupings");
-      makeFactory(new String[]{"a", "a"}, null);
+      final IllegalArgumentException exception = Assertions.assertThrows(
+          IllegalArgumentException.class,
+          () -> makeFactory(new String[]{"a", "a"}, null)
+      );
+      Assertions.assertTrue(
+          exception.getMessage().contains("Encountered same dimension more than once in groupings")
+      );
     }
   }
 
-  @RunWith(Parameterized.class)
+  @ParameterizedClass
+
+  @MethodSource("arguments")
   public static class ValueTests
   {
     private final GroupingAggregatorFactory factory;
@@ -153,7 +163,6 @@ public class GroupingAggregatorFactoryTest
       this.value = value;
     }
 
-    @Parameterized.Parameters
     public static Collection arguments()
     {
       String[] maxGroupingList = new String[Long.SIZE - 1];
@@ -175,7 +184,7 @@ public class GroupingAggregatorFactoryTest
     @Test
     public void testValue()
     {
-      Assert.assertEquals(value, factory.factorize(null).getLong());
+      Assertions.assertEquals(value, factory.factorize(null).getLong());
     }
   }
 }
diff --git a/processing/src/test/java/org/apache/druid/query/aggregation/MetricManipulatorFnsTest.java b/processing/src/test/java/org/apache/druid/query/aggregation/MetricManipulatorFnsTest.java
index 68fe2981875..94924d776f9 100644
--- a/processing/src/test/java/org/apache/druid/query/aggregation/MetricManipulatorFnsTest.java
+++ b/processing/src/test/java/org/apache/druid/query/aggregation/MetricManipulatorFnsTest.java
@@ -23,21 +23,22 @@ import org.apache.druid.hll.HyperLogLogCollector;
 import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.query.aggregation.hyperloglog.HyperUniquesAggregatorFactory;
 import org.apache.druid.segment.TestLongColumnSelector;
-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.Test;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 
-@RunWith(Parameterized.class)
+@ParameterizedClass
+
+@MethodSource("constructorFeeder")
 public class MetricManipulatorFnsTest
 {
   private static final String NAME = "name";
   private static final String FIELD = "field";
 
-  @Parameterized.Parameters(name = "{0}")
   public static Iterable<Object[]> constructorFeeder()
   {
     final ArrayList<Object[]> constructorArrays = new ArrayList<>();
@@ -116,12 +117,14 @@ public class MetricManipulatorFnsTest
 
 
     for (Object[] argList : constructorArrays) {
-      Assert.assertEquals(
+      Assertions.assertEquals(
+          6,
+          argList.length,
           StringUtils.format(
               "Arglist %s is too short. Expected 6 found %d",
               Arrays.toString(argList),
               argList.length
-          ), 6, argList.length
+          )
       );
     }
     return constructorArrays;
@@ -154,21 +157,21 @@ public class MetricManipulatorFnsTest
   @Test
   public void testIdentity()
   {
-    Assert.assertEquals(identity, agg);
-    Assert.assertEquals(identity, MetricManipulatorFns.identity().manipulate(aggregatorFactory, agg));
+    Assertions.assertEquals(identity, agg);
+    Assertions.assertEquals(identity, MetricManipulatorFns.identity().manipulate(aggregatorFactory, agg));
   }
 
   @Test
   public void testFinalize()
   {
-    Assert.assertEquals(identity, agg);
-    Assert.assertEquals(finalize, MetricManipulatorFns.finalizing().manipulate(aggregatorFactory, agg));
+    Assertions.assertEquals(identity, agg);
+    Assertions.assertEquals(finalize, MetricManipulatorFns.finalizing().manipulate(aggregatorFactory, agg));
   }
 
   @Test
   public void testDeserialize()
   {
-    Assert.assertEquals(identity, agg);
-    Assert.assertEquals(deserForm, MetricManipulatorFns.deserializing().manipulate(aggregatorFactory, serialForm));
+    Assertions.assertEquals(identity, agg);
+    Assertions.assertEquals(deserForm, MetricManipulatorFns.deserializing().manipulate(aggregatorFactory, serialForm));
   }
 }
diff --git a/processing/src/test/java/org/apache/druid/query/aggregation/SerializablePairLongStringBufferStoreTest.java b/processing/src/test/java/org/apache/druid/query/aggregation/SerializablePairLongStringBufferStoreTest.java
index a48e719a8bd..eda20be7bc5 100644
--- a/processing/src/test/java/org/apache/druid/query/aggregation/SerializablePairLongStringBufferStoreTest.java
+++ b/processing/src/test/java/org/apache/druid/query/aggregation/SerializablePairLongStringBufferStoreTest.java
@@ -31,9 +31,9 @@ import org.apache.druid.segment.serde.cell.NativeClearedByteBufferProvider;
 import org.apache.druid.segment.writeout.HeapByteBufferWriteOutBytes;
 import org.apache.druid.segment.writeout.OnHeapMemorySegmentWriteOutMedium;
 import org.apache.druid.segment.writeout.SegmentWriteOutMedium;
-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.io.IOException;
 import java.nio.ByteBuffer;
@@ -63,7 +63,7 @@ public class SerializablePairLongStringBufferStoreTest
 
   private SerializablePairLongStringBufferStore bufferStore;
 
-  @Before
+  @BeforeEach
   public void setup() throws Exception
   {
     bufferStore = new SerializablePairLongStringBufferStore(
@@ -84,7 +84,7 @@ public class SerializablePairLongStringBufferStoreTest
 
     int i = 0;
     while (iterator.hasNext()) {
-      Assert.assertEquals(integerRangeArr[i], iterator.next());
+      Assertions.assertEquals(integerRangeArr[i], iterator.next());
       i++;
     }
   }
@@ -94,7 +94,7 @@ public class SerializablePairLongStringBufferStoreTest
   {
     IOIterator<SerializablePairLongString> iterator = bufferStore.iterator();
 
-    Assert.assertFalse(iterator.hasNext());
+    Assertions.assertFalse(iterator.hasNext());
   }
 
   @Test
@@ -102,8 +102,8 @@ public class SerializablePairLongStringBufferStoreTest
   {
     bufferStore.store(null);
     IOIterator<SerializablePairLongString> iterator = bufferStore.iterator();
-    Assert.assertTrue(iterator.hasNext());
-    Assert.assertNull(iterator.next());
+    Assertions.assertTrue(iterator.hasNext());
+    Assertions.assertNull(iterator.next());
   }
 
   @Test
@@ -113,23 +113,23 @@ public class SerializablePairLongStringBufferStoreTest
 
     IOIterator<SerializablePairLongString> iterator = bufferStore.iterator();
 
-    Assert.assertTrue(iterator.hasNext());
+    Assertions.assertTrue(iterator.hasNext());
     // expect hasNext() to not modify state
-    Assert.assertTrue(iterator.hasNext());
+    Assertions.assertTrue(iterator.hasNext());
   }
 
-  @Test(expected = NoSuchElementException.class)
+  @Test
   public void testIteratorEmptyThrows() throws Exception
   {
-    IOIterator<SerializablePairLongString> iterator = bufferStore.iterator();
-    iterator.next();
+    final IOIterator<SerializablePairLongString> iterator = bufferStore.iterator();
+    Assertions.assertThrows(NoSuchElementException.class, iterator::next);
   }
 
   @Test
   public void testIteratorEmptyHasNext() throws Exception
   {
     IOIterator<SerializablePairLongString> iterator = bufferStore.iterator();
-    Assert.assertFalse(iterator.hasNext());
+    Assertions.assertFalse(iterator.hasNext());
   }
 
   @Test
@@ -140,8 +140,8 @@ public class SerializablePairLongStringBufferStoreTest
     }
 
     SerializablePairLongStringColumnHeader columnHeader = (SerializablePairLongStringColumnHeader) bufferStore.createColumnHeader();
-    Assert.assertEquals(integerRangeArr[0].lhs.longValue(), columnHeader.getMinValue());
-    Assert.assertTrue(columnHeader.isUseIntegerDeltas());
+    Assertions.assertEquals(integerRangeArr[0].lhs.longValue(), columnHeader.getMinValue());
+    Assertions.assertTrue(columnHeader.isUseIntegerDeltas());
   }
 
   @Test
@@ -152,8 +152,8 @@ public class SerializablePairLongStringBufferStoreTest
     }
 
     SerializablePairLongStringColumnHeader columnHeader = (SerializablePairLongStringColumnHeader) bufferStore.createColumnHeader();
-    Assert.assertEquals(MIN_LONG, columnHeader.getMinValue());
-    Assert.assertFalse(columnHeader.isUseIntegerDeltas());
+    Assertions.assertEquals(MIN_LONG, columnHeader.getMinValue());
+    Assertions.assertFalse(columnHeader.isUseIntegerDeltas());
   }
 
   @Test
@@ -175,8 +175,8 @@ public class SerializablePairLongStringBufferStoreTest
 
       SerializablePairLongStringColumnHeader deserializedColumnhHeader =
           (SerializablePairLongStringColumnHeader) AbstractSerializablePairLongObjectColumnHeader.fromBuffer(byteBuffer, SerializablePairLongString.class);
-      Assert.assertEquals(MIN_INTEGER, deserializedColumnhHeader.getMinValue());
-      Assert.assertTrue(deserializedColumnhHeader.isUseIntegerDeltas());
+      Assertions.assertEquals(MIN_INTEGER, deserializedColumnhHeader.getMinValue());
+      Assertions.assertTrue(deserializedColumnhHeader.isUseIntegerDeltas());
     }
   }
 
@@ -201,8 +201,8 @@ public class SerializablePairLongStringBufferStoreTest
 
       SerializablePairLongStringColumnHeader deserializedColumnhHeader =
           (SerializablePairLongStringColumnHeader) AbstractSerializablePairLongObjectColumnHeader.fromBuffer(byteBuffer, SerializablePairLongString.class);
-      Assert.assertEquals(MIN_LONG, deserializedColumnhHeader.getMinValue());
-      Assert.assertFalse(deserializedColumnhHeader.isUseIntegerDeltas());
+      Assertions.assertEquals(MIN_LONG, deserializedColumnhHeader.getMinValue());
+      Assertions.assertFalse(deserializedColumnhHeader.isUseIntegerDeltas());
     }
   }
 
@@ -231,7 +231,7 @@ public class SerializablePairLongStringBufferStoreTest
     int i = 0;
 
     while (iterator.hasNext()) {
-      Assert.assertEquals(input.get(i), iterator.next());
+      Assertions.assertEquals(input.get(i), iterator.next());
       i++;
     }
   }
@@ -248,9 +248,9 @@ public class SerializablePairLongStringBufferStoreTest
 
     IOIterator<SerializablePairLongString> iterator = bufferStore.iterator();
 
-    Assert.assertTrue(iterator.hasNext());
-    Assert.assertEquals(value, iterator.next());
-    Assert.assertFalse(iterator.hasNext());
+    Assertions.assertTrue(iterator.hasNext());
+    Assertions.assertEquals(value, iterator.next());
+    Assertions.assertFalse(iterator.hasNext());
   }
 
   @Test
@@ -273,14 +273,14 @@ public class SerializablePairLongStringBufferStoreTest
 
     SerializablePairLongStringColumnHeader columnHeader = (SerializablePairLongStringColumnHeader) bufferStore.createColumnHeader();
 
-    Assert.assertEquals(0, columnHeader.getMinValue());
+    Assertions.assertEquals(0, columnHeader.getMinValue());
 
     AbstractSerializablePairLongObjectBufferStore.TransferredBuffer transferredBuffer = bufferStore.transferToRowWriter(
         NativeClearedByteBufferProvider.INSTANCE,
         writeOutMedium
     );
 
-    Assert.assertEquals(94, transferredBuffer.getSerializedSize());
+    Assertions.assertEquals(94, transferredBuffer.getSerializedSize());
   }
 
   @Test
@@ -294,14 +294,14 @@ public class SerializablePairLongStringBufferStoreTest
 
     SerializablePairLongStringColumnHeader columnHeader = (SerializablePairLongStringColumnHeader) bufferStore.createColumnHeader();
 
-    Assert.assertEquals(0, columnHeader.getMinValue());
+    Assertions.assertEquals(0, columnHeader.getMinValue());
 
     AbstractSerializablePairLongObjectBufferStore.TransferredBuffer transferredBuffer = bufferStore.transferToRowWriter(
         NativeClearedByteBufferProvider.INSTANCE,
         writeOutMedium
     );
 
-    Assert.assertEquals(59, transferredBuffer.getSerializedSize());
+    Assertions.assertEquals(59, transferredBuffer.getSerializedSize());
   }
 
   @Test
@@ -311,7 +311,7 @@ public class SerializablePairLongStringBufferStoreTest
       bufferStore.store(value);
     }
 
-    Assert.assertTrue(bufferStore.createColumnHeader().isUseIntegerDeltas());
+    Assertions.assertTrue(bufferStore.createColumnHeader().isUseIntegerDeltas());
 
     assertTransferredValuesEqual(integerRangeArr);
   }
@@ -323,7 +323,7 @@ public class SerializablePairLongStringBufferStoreTest
       bufferStore.store(value);
     }
 
-    Assert.assertFalse(bufferStore.createColumnHeader().isUseIntegerDeltas());
+    Assertions.assertFalse(bufferStore.createColumnHeader().isUseIntegerDeltas());
 
     assertTransferredValuesEqual(longRangeArr);
   }
@@ -338,14 +338,14 @@ public class SerializablePairLongStringBufferStoreTest
     int i = 0;
 
     while (iterator.hasNext()) {
-      Assert.assertEquals(input.get(i), iterator.next());
+      Assertions.assertEquals(input.get(i), iterator.next());
       i++;
     }
 
-    Assert.assertEquals(
-        StringUtils.format("element count mismatch: expected %s, got %s", input.size(), i),
+    Assertions.assertEquals(
         input.size(),
-        i
+        i,
+        StringUtils.format("element count mismatch: expected %s, got %s", input.size(), i)
     );
   }
 
@@ -359,7 +359,7 @@ public class SerializablePairLongStringBufferStoreTest
 
     try (SerializablePairLongStringComplexColumn column = createComplexColumn(transferredBuffer, resultChannel)) {
       for (int i = 0; i < input.length; i++) {
-        Assert.assertEquals(input[i], column.getRowValue(i));
+        Assertions.assertEquals(input[i], column.getRowValue(i));
       }
     }
   }
diff --git a/processing/src/test/java/org/apache/druid/query/aggregation/StringColumnAggregationTest.java b/processing/src/test/java/org/apache/druid/query/aggregation/StringColumnAggregationTest.java
index 9e4dcd14083..b4fc1c6e943 100644
--- a/processing/src/test/java/org/apache/druid/query/aggregation/StringColumnAggregationTest.java
+++ b/processing/src/test/java/org/apache/druid/query/aggregation/StringColumnAggregationTest.java
@@ -41,16 +41,16 @@ import org.apache.druid.segment.IndexBuilder;
 import org.apache.druid.segment.Segment;
 import org.apache.druid.segment.incremental.IncrementalIndex;
 import org.apache.druid.segment.incremental.IncrementalIndexSchema;
+import org.apache.druid.testing.TemporaryFolderExtension;
 import org.apache.druid.timeline.SegmentId;
 import org.apache.druid.utils.CloseableUtils;
 import org.joda.time.DateTime;
 import org.joda.time.DateTimeZone;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-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 java.util.ArrayList;
 import java.util.Collections;
@@ -58,8 +58,8 @@ import java.util.List;
 
 public class StringColumnAggregationTest
 {
-  @Rule
-  public final TemporaryFolder tempFolder = new TemporaryFolder();
+  @RegisterExtension
+  public final TemporaryFolderExtension tempFolder = new TemporaryFolderExtension();
 
   private final String singleValue = "singleValue";
   private final String multiValue = "multiValue";
@@ -79,7 +79,7 @@ public class StringColumnAggregationTest
 
   private AggregationTestHelper aggregationTestHelper;
 
-  @Before
+  @BeforeEach
   public void setup() throws Exception
   {
     List<String> dimensions = ImmutableList.of(singleValue, multiValue);
@@ -97,7 +97,7 @@ public class StringColumnAggregationTest
       ));
     }
 
-    aggregationTestHelper = AggregationTestHelper.createGroupByQueryAggregationTestHelper(
+    aggregationTestHelper = AggregationTestHelper.createGroupByQueryAggregationTestHelperWithTemporaryFolderExtension(
         Collections.emptyList(),
         new GroupByQueryConfig(),
         tempFolder
@@ -136,7 +136,7 @@ public class StringColumnAggregationTest
     multiValueMin = 1;
   }
 
-  @After
+  @AfterEach
   public void tearDown()
   {
     if (segments != null) {
@@ -182,28 +182,28 @@ public class StringColumnAggregationTest
     Sequence<ResultRow> seq = aggregationTestHelper.runQueryOnSegmentsObjs(segments, query);
     Row result = Iterables.getOnlyElement(seq.toList()).toMapBasedRow(query);
 
-    Assert.assertEquals(numRows, result.getMetric("count").longValue());
+    Assertions.assertEquals(numRows, result.getMetric("count").longValue());
     
-    Assert.assertEquals(singleValueSum, result.getMetric("singleDoubleSum").doubleValue(), 0.0001d);
-    Assert.assertEquals(multiValueSum, result.getMetric("multiDoubleSum").doubleValue(), 0.0001d);
-    Assert.assertEquals(singleValueMax, result.getMetric("singleDoubleMax").doubleValue(), 0.0001d);
-    Assert.assertEquals(multiValueMax, result.getMetric("multiDoubleMax").doubleValue(), 0.0001d);
-    Assert.assertEquals(singleValueMin, result.getMetric("singleDoubleMin").doubleValue(), 0.0001d);
-    Assert.assertEquals(multiValueMin, result.getMetric("multiDoubleMin").doubleValue(), 0.0001d);
+    Assertions.assertEquals(singleValueSum, result.getMetric("singleDoubleSum").doubleValue(), 0.0001d);
+    Assertions.assertEquals(multiValueSum, result.getMetric("multiDoubleSum").doubleValue(), 0.0001d);
+    Assertions.assertEquals(singleValueMax, result.getMetric("singleDoubleMax").doubleValue(), 0.0001d);
+    Assertions.assertEquals(multiValueMax, result.getMetric("multiDoubleMax").doubleValue(), 0.0001d);
+    Assertions.assertEquals(singleValueMin, result.getMetric("singleDoubleMin").doubleValue(), 0.0001d);
+    Assertions.assertEquals(multiValueMin, result.getMetric("multiDoubleMin").doubleValue(), 0.0001d);
 
-    Assert.assertEquals(singleValueSum, result.getMetric("singleFloatSum").floatValue(), 0.0001f);
-    Assert.assertEquals(multiValueSum, result.getMetric("multiFloatSum").floatValue(), 0.0001f);
-    Assert.assertEquals(singleValueMax, result.getMetric("singleFloatMax").floatValue(), 0.0001f);
-    Assert.assertEquals(multiValueMax, result.getMetric("multiFloatMax").floatValue(), 0.0001f);
-    Assert.assertEquals(singleValueMin, result.getMetric("singleFloatMin").floatValue(), 0.0001f);
-    Assert.assertEquals(multiValueMin, result.getMetric("multiFloatMin").floatValue(), 0.0001f);
+    Assertions.assertEquals(singleValueSum, result.getMetric("singleFloatSum").floatValue(), 0.0001f);
+    Assertions.assertEquals(multiValueSum, result.getMetric("multiFloatSum").floatValue(), 0.0001f);
+    Assertions.assertEquals(singleValueMax, result.getMetric("singleFloatMax").floatValue(), 0.0001f);
+    Assertions.assertEquals(multiValueMax, result.getMetric("multiFloatMax").floatValue(), 0.0001f);
+    Assertions.assertEquals(singleValueMin, result.getMetric("singleFloatMin").floatValue(), 0.0001f);
+    Assertions.assertEquals(multiValueMin, result.getMetric("multiFloatMin").floatValue(), 0.0001f);
 
-    Assert.assertEquals((long) singleValueSum, result.getMetric("singleLongSum").longValue());
-    Assert.assertEquals((long) multiValueSum, result.getMetric("multiLongSum").longValue());
-    Assert.assertEquals((long) singleValueMax, result.getMetric("singleLongMax").longValue());
-    Assert.assertEquals((long) multiValueMax, result.getMetric("multiLongMax").longValue());
-    Assert.assertEquals((long) singleValueMin, result.getMetric("singleLongMin").longValue());
-    Assert.assertEquals((long) multiValueMin, result.getMetric("multiLongMin").longValue());
+    Assertions.assertEquals((long) singleValueSum, result.getMetric("singleLongSum").longValue());
+    Assertions.assertEquals((long) multiValueSum, result.getMetric("multiLongSum").longValue());
+    Assertions.assertEquals((long) singleValueMax, result.getMetric("singleLongMax").longValue());
+    Assertions.assertEquals((long) multiValueMax, result.getMetric("multiLongMax").longValue());
+    Assertions.assertEquals((long) singleValueMin, result.getMetric("singleLongMin").longValue());
+    Assertions.assertEquals((long) multiValueMin, result.getMetric("multiLongMin").longValue());
   }
 
   @Test
@@ -239,30 +239,33 @@ public class StringColumnAggregationTest
                                   )
                                   .build();
 
-    Sequence seq = AggregationTestHelper.createTimeseriesQueryAggregationTestHelper(Collections.emptyList(), tempFolder)
+    Sequence seq = AggregationTestHelper.createTimeseriesQueryAggregationTestHelperWithTemporaryFolderExtension(
+        Collections.emptyList(),
+        tempFolder
+    )
                                         .runQueryOnSegmentsObjs(segments, query);
     TimeseriesResultValue result = ((Result<TimeseriesResultValue>) Iterables.getOnlyElement(seq.toList())).getValue();
 
-    Assert.assertEquals(numRows, result.getLongMetric("count").longValue());
-    Assert.assertEquals(singleValueSum, result.getDoubleMetric("singleDoubleSum").doubleValue(), 0.0001d);
-    Assert.assertEquals(multiValueSum, result.getDoubleMetric("multiDoubleSum").doubleValue(), 0.0001d);
-    Assert.assertEquals(singleValueMax, result.getDoubleMetric("singleDoubleMax").doubleValue(), 0.0001d);
-    Assert.assertEquals(multiValueMax, result.getDoubleMetric("multiDoubleMax").doubleValue(), 0.0001d);
-    Assert.assertEquals(singleValueMin, result.getDoubleMetric("singleDoubleMin").doubleValue(), 0.0001d);
-    Assert.assertEquals(multiValueMin, result.getDoubleMetric("multiDoubleMin").doubleValue(), 0.0001d);
+    Assertions.assertEquals(numRows, result.getLongMetric("count").longValue());
+    Assertions.assertEquals(singleValueSum, result.getDoubleMetric("singleDoubleSum").doubleValue(), 0.0001d);
+    Assertions.assertEquals(multiValueSum, result.getDoubleMetric("multiDoubleSum").doubleValue(), 0.0001d);
+    Assertions.assertEquals(singleValueMax, result.getDoubleMetric("singleDoubleMax").doubleValue(), 0.0001d);
+    Assertions.assertEquals(multiValueMax, result.getDoubleMetric("multiDoubleMax").doubleValue(), 0.0001d);
+    Assertions.assertEquals(singleValueMin, result.getDoubleMetric("singleDoubleMin").doubleValue(), 0.0001d);
+    Assertions.assertEquals(multiValueMin, result.getDoubleMetric("multiDoubleMin").doubleValue(), 0.0001d);
 
-    Assert.assertEquals(singleValueSum, result.getFloatMetric("singleFloatSum").floatValue(), 0.0001f);
-    Assert.assertEquals(multiValueSum, result.getFloatMetric("multiFloatSum").floatValue(), 0.0001f);
-    Assert.assertEquals(singleValueMax, result.getFloatMetric("singleFloatMax").floatValue(), 0.0001f);
-    Assert.assertEquals(multiValueMax, result.getFloatMetric("multiFloatMax").floatValue(), 0.0001f);
-    Assert.assertEquals(singleValueMin, result.getFloatMetric("singleFloatMin").floatValue(), 0.0001f);
-    Assert.assertEquals(multiValueMin, result.getFloatMetric("multiFloatMin").floatValue(), 0.0001f);
+    Assertions.assertEquals(singleValueSum, result.getFloatMetric("singleFloatSum").floatValue(), 0.0001f);
+    Assertions.assertEquals(multiValueSum, result.getFloatMetric("multiFloatSum").floatValue(), 0.0001f);
+    Assertions.assertEquals(singleValueMax, result.getFloatMetric("singleFloatMax").floatValue(), 0.0001f);
+    Assertions.assertEquals(multiValueMax, result.getFloatMetric("multiFloatMax").floatValue(), 0.0001f);
+    Assertions.assertEquals(singleValueMin, result.getFloatMetric("singleFloatMin").floatValue(), 0.0001f);
+    Assertions.assertEquals(multiValueMin, result.getFloatMetric("multiFloatMin").floatValue(), 0.0001f);
 
-    Assert.assertEquals((long) singleValueSum, result.getLongMetric("singleLongSum").longValue());
-    Assert.assertEquals((long) multiValueSum, result.getLongMetric("multiLongSum").longValue());
-    Assert.assertEquals((long) singleValueMax, result.getLongMetric("singleLongMax").longValue());
-    Assert.assertEquals((long) multiValueMax, result.getLongMetric("multiLongMax").longValue());
-    Assert.assertEquals((long) singleValueMin, result.getLongMetric("singleLongMin").longValue());
-    Assert.assertEquals((long) multiValueMin, result.getLongMetric("multiLongMin").longValue());
+    Assertions.assertEquals((long) singleValueSum, result.getLongMetric("singleLongSum").longValue());
+    Assertions.assertEquals((long) multiValueSum, result.getLongMetric("multiLongSum").longValue());
+    Assertions.assertEquals((long) singleValueMax, result.getLongMetric("singleLongMax").longValue());
+    Assertions.assertEquals((long) multiValueMax, result.getLongMetric("multiLongMax").longValue());
+    Assertions.assertEquals((long) singleValueMin, result.getLongMetric("singleLongMin").longValue());
+    Assertions.assertEquals((long) multiValueMin, result.getLongMetric("multiLongMin").longValue());
   }
 }
diff --git a/processing/src/test/java/org/apache/druid/query/aggregation/cardinality/CardinalityAggregatorTest.java b/processing/src/test/java/org/apache/druid/query/aggregation/cardinality/CardinalityAggregatorTest.java
index 5b9cdef271f..a811a7cb156 100644
--- a/processing/src/test/java/org/apache/druid/query/aggregation/cardinality/CardinalityAggregatorTest.java
+++ b/processing/src/test/java/org/apache/druid/query/aggregation/cardinality/CardinalityAggregatorTest.java
@@ -49,8 +49,8 @@ import org.apache.druid.segment.DimensionSelectorUtils;
 import org.apache.druid.segment.IdLookup;
 import org.apache.druid.segment.data.IndexedInts;
 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 javax.annotation.Nullable;
 import java.nio.ByteBuffer;
@@ -389,8 +389,8 @@ public class CardinalityAggregatorTest extends InitializedNullHandlingTest
     for (int i = 0; i < VALUES1.size(); ++i) {
       aggregate(selectorList, agg);
     }
-    Assert.assertEquals(9.0, (Double) rowAggregatorFactory.finalizeComputation(agg.get()), 0.05);
-    Assert.assertEquals(9L, rowAggregatorFactoryRounded.finalizeComputation(agg.get()));
+    Assertions.assertEquals(9.0, (Double) rowAggregatorFactory.finalizeComputation(agg.get()), 0.05);
+    Assertions.assertEquals(9L, rowAggregatorFactoryRounded.finalizeComputation(agg.get()));
   }
 
   @Test
@@ -404,12 +404,12 @@ public class CardinalityAggregatorTest extends InitializedNullHandlingTest
     for (int i = 0; i < VALUES1.size(); ++i) {
       aggregate(selectorList, agg);
     }
-    Assert.assertEquals(
+    Assertions.assertEquals(
         6.0,
         (Double) valueAggregatorFactory.finalizeComputation(agg.get()),
         0.05
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         6L,
         rowAggregatorFactoryRounded.finalizeComputation(agg.get())
     );
@@ -434,8 +434,8 @@ public class CardinalityAggregatorTest extends InitializedNullHandlingTest
     for (int i = 0; i < VALUES1.size(); ++i) {
       bufferAggregate(selectorList, agg, buf, pos);
     }
-    Assert.assertEquals(9.0, (Double) rowAggregatorFactory.finalizeComputation(agg.get(buf, pos)), 0.05);
-    Assert.assertEquals(9L, rowAggregatorFactoryRounded.finalizeComputation(agg.get(buf, pos)));
+    Assertions.assertEquals(9.0, (Double) rowAggregatorFactory.finalizeComputation(agg.get(buf, pos)), 0.05);
+    Assertions.assertEquals(9L, rowAggregatorFactoryRounded.finalizeComputation(agg.get(buf, pos)));
   }
 
   @Test
@@ -456,12 +456,12 @@ public class CardinalityAggregatorTest extends InitializedNullHandlingTest
     for (int i = 0; i < VALUES1.size(); ++i) {
       bufferAggregate(selectorList, agg, buf, pos);
     }
-    Assert.assertEquals(
+    Assertions.assertEquals(
         6.0,
         (Double) valueAggregatorFactory.finalizeComputation(agg.get(buf, pos)),
         0.05
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         6L,
         rowAggregatorFactoryRounded.finalizeComputation(agg.get(buf, pos))
     );
@@ -497,10 +497,10 @@ public class CardinalityAggregatorTest extends InitializedNullHandlingTest
       aggregate(selector2, agg2);
     }
 
-    Assert.assertEquals(4.0, (Double) rowAggregatorFactory.finalizeComputation(agg1.get()), 0.05);
-    Assert.assertEquals(8.0, (Double) rowAggregatorFactory.finalizeComputation(agg2.get()), 0.05);
+    Assertions.assertEquals(4.0, (Double) rowAggregatorFactory.finalizeComputation(agg1.get()), 0.05);
+    Assertions.assertEquals(8.0, (Double) rowAggregatorFactory.finalizeComputation(agg2.get()), 0.05);
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         9.0,
         (Double) rowAggregatorFactory.finalizeComputation(
             rowAggregatorFactory.combine(
@@ -542,17 +542,17 @@ public class CardinalityAggregatorTest extends InitializedNullHandlingTest
     for (int i = 0; i < VALUES2.size(); ++i) {
       aggregate(selector2, agg2);
     }
-    Assert.assertEquals(
+    Assertions.assertEquals(
         3.0,
         (Double) valueAggregatorFactory.finalizeComputation(agg1.get()),
         0.05
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         6.0,
         (Double) valueAggregatorFactory.finalizeComputation(agg2.get()),
         0.05
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         6.0,
         (Double) rowAggregatorFactory.finalizeComputation(
             rowAggregatorFactory.combine(
@@ -574,7 +574,7 @@ public class CardinalityAggregatorTest extends InitializedNullHandlingTest
     for (int i = 0; i < VALUES1.size(); ++i) {
       aggregate(selectorListWithExtraction, agg);
     }
-    Assert.assertEquals(9.0, (Double) rowAggregatorFactory.finalizeComputation(agg.get()), 0.05);
+    Assertions.assertEquals(9.0, (Double) rowAggregatorFactory.finalizeComputation(agg.get()), 0.05);
 
     CardinalityAggregator agg2 = new CardinalityAggregator(
         dimInfoListConstantVal,
@@ -583,7 +583,7 @@ public class CardinalityAggregatorTest extends InitializedNullHandlingTest
     for (int i = 0; i < VALUES1.size(); ++i) {
       aggregate(selectorListConstantVal, agg2);
     }
-    Assert.assertEquals(3.0, (Double) rowAggregatorFactory.finalizeComputation(agg2.get()), 0.05);
+    Assertions.assertEquals(3.0, (Double) rowAggregatorFactory.finalizeComputation(agg2.get()), 0.05);
   }
 
   @Test
@@ -596,7 +596,7 @@ public class CardinalityAggregatorTest extends InitializedNullHandlingTest
     for (int i = 0; i < VALUES1.size(); ++i) {
       aggregate(selectorListWithExtraction, agg);
     }
-    Assert.assertEquals(7.0, (Double) valueAggregatorFactory.finalizeComputation(agg.get()), 0.05);
+    Assertions.assertEquals(7.0, (Double) valueAggregatorFactory.finalizeComputation(agg.get()), 0.05);
 
     CardinalityAggregator agg2 = new CardinalityAggregator(
         dimInfoListConstantVal,
@@ -605,7 +605,7 @@ public class CardinalityAggregatorTest extends InitializedNullHandlingTest
     for (int i = 0; i < VALUES1.size(); ++i) {
       aggregate(selectorListConstantVal, agg2);
     }
-    Assert.assertEquals(1.0, (Double) valueAggregatorFactory.finalizeComputation(agg2.get()), 0.05);
+    Assertions.assertEquals(1.0, (Double) valueAggregatorFactory.finalizeComputation(agg2.get()), 0.05);
   }
 
   @Test
@@ -623,7 +623,7 @@ public class CardinalityAggregatorTest extends InitializedNullHandlingTest
         true
     );
     ObjectMapper objectMapper = new DefaultObjectMapper();
-    Assert.assertEquals(
+    Assertions.assertEquals(
         factory,
         objectMapper.readValue(objectMapper.writeValueAsString(factory), AggregatorFactory.class)
     );
@@ -635,7 +635,7 @@ public class CardinalityAggregatorTest extends InitializedNullHandlingTest
                             + "\"byRow\":true,"
                             + "\"round\":true"
                             + "}";
-    Assert.assertEquals(
+    Assertions.assertEquals(
         factory,
         objectMapper.readValue(fieldNamesOnly, AggregatorFactory.class)
     );
@@ -650,7 +650,7 @@ public class CardinalityAggregatorTest extends InitializedNullHandlingTest
         true
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         factory2,
         objectMapper.readValue(objectMapper.writeValueAsString(factory2), AggregatorFactory.class)
     );
@@ -667,8 +667,8 @@ public class CardinalityAggregatorTest extends InitializedNullHandlingTest
     for (int i = 0; i < VALUES1.size(); ++i) {
       aggregate(selectorList, agg);
     }
-    Assert.assertEquals(9.0, (Double) rowAggregatorFactory.finalizeComputation(agg.get()), 0.05);
-    Assert.assertEquals(9L, rowAggregatorFactoryRounded.finalizeComputation(agg.get()));
+    Assertions.assertEquals(9.0, (Double) rowAggregatorFactory.finalizeComputation(agg.get()), 0.05);
+    Assertions.assertEquals(9L, rowAggregatorFactoryRounded.finalizeComputation(agg.get()));
   }
 
   @Test
@@ -682,12 +682,12 @@ public class CardinalityAggregatorTest extends InitializedNullHandlingTest
     for (int i = 0; i < VALUES1.size(); ++i) {
       aggregate(selectorList, agg);
     }
-    Assert.assertEquals(
+    Assertions.assertEquals(
         6.0,
         (Double) valueAggregatorFactory.finalizeComputation(agg.get()),
         0.05
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         6L,
         rowAggregatorFactoryRounded.finalizeComputation(agg.get())
     );
@@ -723,17 +723,17 @@ public class CardinalityAggregatorTest extends InitializedNullHandlingTest
     for (int i = 0; i < VALUES2.size(); ++i) {
       aggregate(selector2, agg2);
     }
-    Assert.assertEquals(
+    Assertions.assertEquals(
         3.0,
         (Double) valueAggregatorFactory.finalizeComputation(agg1.get()),
         0.05
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         6.0,
         (Double) valueAggregatorFactory.finalizeComputation(agg2.get()),
         0.05
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         6.0,
         (Double) rowAggregatorFactory.finalizeComputation(
             rowAggregatorFactory.combine(
diff --git a/processing/src/test/java/org/apache/druid/query/aggregation/firstlast/last/StringLastVectorAggregatorTest.java b/processing/src/test/java/org/apache/druid/query/aggregation/firstlast/last/StringLastVectorAggregatorTest.java
index 200787c85c4..f5cd494312c 100644
--- a/processing/src/test/java/org/apache/druid/query/aggregation/firstlast/last/StringLastVectorAggregatorTest.java
+++ b/processing/src/test/java/org/apache/druid/query/aggregation/firstlast/last/StringLastVectorAggregatorTest.java
@@ -38,11 +38,12 @@ import org.apache.druid.segment.vector.VectorColumnSelectorFactory;
 import org.apache.druid.segment.vector.VectorObjectSelector;
 import org.apache.druid.segment.vector.VectorValueSelector;
 import org.apache.druid.testing.InitializedNullHandlingTest;
-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 javax.annotation.Nullable;
+
 import java.nio.ByteBuffer;
 import java.util.concurrent.ThreadLocalRandom;
 
@@ -83,7 +84,7 @@ public class StringLastVectorAggregatorTest extends InitializedNullHandlingTest
   private VectorColumnSelectorFactory selectorFactory;
 
 
-  @Before
+  @BeforeEach
   public void setup()
   {
     byte[] randomBytes = new byte[1024];
@@ -331,30 +332,30 @@ public class StringLastVectorAggregatorTest extends InitializedNullHandlingTest
     targetWithPairs.aggregate(buf, 0, 0, pairs.length);
     Pair<Long, String> result = (Pair<Long, String>) targetWithPairs.get(buf, 0);
     //Should come 0 as the last value as the left of the pair is greater
-    Assert.assertEquals(pairs[0].lhs.longValue(), result.lhs.longValue());
-    Assert.assertEquals(pairs[0].rhs, result.rhs);
+    Assertions.assertEquals(pairs[0].lhs.longValue(), result.lhs.longValue());
+    Assertions.assertEquals(pairs[0].rhs, result.rhs);
   }
 
   @Test
   public void testFactory()
   {
-    Assert.assertTrue(stringLastAggregatorFactory.canVectorize(selectorFactory));
+    Assertions.assertTrue(stringLastAggregatorFactory.canVectorize(selectorFactory));
     VectorAggregator vectorAggregator = stringLastAggregatorFactory.factorizeVector(selectorFactory);
-    Assert.assertNotNull(vectorAggregator);
-    Assert.assertEquals(StringLastVectorAggregator.class, vectorAggregator.getClass());
+    Assertions.assertNotNull(vectorAggregator);
+    Assertions.assertEquals(StringLastVectorAggregator.class, vectorAggregator.getClass());
   }
 
   @Test
   public void testStringLastOnNonStringColumns()
   {
-    Assert.assertTrue(stringLastAggregatorFactory1.canVectorize(selectorFactory));
+    Assertions.assertTrue(stringLastAggregatorFactory1.canVectorize(selectorFactory));
     VectorAggregator vectorAggregator = stringLastAggregatorFactory1.factorizeVector(selectorFactory);
-    Assert.assertNotNull(vectorAggregator);
-    Assert.assertEquals(StringLastVectorAggregator.class, vectorAggregator.getClass());
+    Assertions.assertNotNull(vectorAggregator);
+    Assertions.assertEquals(StringLastVectorAggregator.class, vectorAggregator.getClass());
     vectorAggregator.aggregate(buf, 0, 0, LONG_VALUES.length);
     Pair<Long, String> result = (Pair<Long, String>) vectorAggregator.get(buf, 0);
-    Assert.assertEquals(times[3], result.lhs.longValue());
-    Assert.assertEquals(STRING_VALUES[3], result.rhs);
+    Assertions.assertEquals(times[3], result.lhs.longValue());
+    Assertions.assertEquals(STRING_VALUES[3], result.rhs);
   }
 
   @Test
@@ -362,7 +363,7 @@ public class StringLastVectorAggregatorTest extends InitializedNullHandlingTest
   {
     target.init(buf, 0);
     long initVal = buf.getLong(0);
-    Assert.assertEquals(DateTimes.MIN.getMillis(), initVal);
+    Assertions.assertEquals(DateTimes.MIN.getMillis(), initVal);
   }
 
   @Test
@@ -370,8 +371,8 @@ public class StringLastVectorAggregatorTest extends InitializedNullHandlingTest
   {
     target.aggregate(buf, 0, 0, VALUES.length);
     Pair<Long, String> result = (Pair<Long, String>) target.get(buf, 0);
-    Assert.assertEquals(times[3], result.lhs.longValue());
-    Assert.assertEquals(VALUES[3], result.rhs);
+    Assertions.assertEquals(times[3], result.lhs.longValue());
+    Assertions.assertEquals(VALUES[3], result.rhs);
   }
 
   @Test
@@ -402,8 +403,8 @@ public class StringLastVectorAggregatorTest extends InitializedNullHandlingTest
     target.aggregate(buf, 3, positions, null, positionOffset);
     for (int i = 0; i < positions.length; i++) {
       Pair<Long, String> result = (Pair<Long, String>) target.get(buf, positions[i] + positionOffset);
-      Assert.assertEquals(times[i], result.lhs.longValue());
-      Assert.assertEquals(VALUES[i], result.rhs);
+      Assertions.assertEquals(times[i], result.lhs.longValue());
+      Assertions.assertEquals(VALUES[i], result.rhs);
     }
   }
 
@@ -417,8 +418,8 @@ public class StringLastVectorAggregatorTest extends InitializedNullHandlingTest
     target.aggregate(buf, 3, positions, rows, positionOffset);
     for (int i = 0; i < positions.length; i++) {
       Pair<Long, String> result = (Pair<Long, String>) target.get(buf, positions[i] + positionOffset);
-      Assert.assertEquals(times[rows[i]], result.lhs.longValue());
-      Assert.assertEquals(VALUES[rows[i]], result.rhs);
+      Assertions.assertEquals(times[rows[i]], result.lhs.longValue());
+      Assertions.assertEquals(VALUES[rows[i]], result.rhs);
     }
   }
 
@@ -427,8 +428,8 @@ public class StringLastVectorAggregatorTest extends InitializedNullHandlingTest
   {
     targetSingleDim.aggregate(buf, 0, 0, VALUES.length);
     Pair<Long, String> result = (Pair<Long, String>) targetSingleDim.get(buf, 0);
-    Assert.assertEquals(times[3], result.lhs.longValue());
-    Assert.assertEquals(VALUES[3], result.rhs);
+    Assertions.assertEquals(times[3], result.lhs.longValue());
+    Assertions.assertEquals(VALUES[3], result.rhs);
   }
 
   @Test
@@ -440,8 +441,8 @@ public class StringLastVectorAggregatorTest extends InitializedNullHandlingTest
     targetSingleDim.aggregate(buf, 3, positions, null, positionOffset);
     for (int i = 0; i < positions.length; i++) {
       Pair<Long, String> result = (Pair<Long, String>) targetSingleDim.get(buf, positions[i] + positionOffset);
-      Assert.assertEquals(times[i], result.lhs.longValue());
-      Assert.assertEquals(VALUES[i], result.rhs);
+      Assertions.assertEquals(times[i], result.lhs.longValue());
+      Assertions.assertEquals(VALUES[i], result.rhs);
     }
   }
 
@@ -455,8 +456,8 @@ public class StringLastVectorAggregatorTest extends InitializedNullHandlingTest
     targetSingleDim.aggregate(buf, 3, positions, rows, positionOffset);
     for (int i = 0; i < positions.length; i++) {
       Pair<Long, String> result = (Pair<Long, String>) targetSingleDim.get(buf, positions[i] + positionOffset);
-      Assert.assertEquals(times[rows[i]], result.lhs.longValue());
-      Assert.assertEquals(VALUES[rows[i]], result.rhs);
+      Assertions.assertEquals(times[rows[i]], result.lhs.longValue());
+      Assertions.assertEquals(VALUES[rows[i]], result.rhs);
     }
   }
 
diff --git a/processing/src/test/java/org/apache/druid/query/aggregation/hyperloglog/HyperUniquesAggregationTest.java b/processing/src/test/java/org/apache/druid/query/aggregation/hyperloglog/HyperUniquesAggregationTest.java
index c5b34324749..3225df4a9d2 100644
--- a/processing/src/test/java/org/apache/druid/query/aggregation/hyperloglog/HyperUniquesAggregationTest.java
+++ b/processing/src/test/java/org/apache/druid/query/aggregation/hyperloglog/HyperUniquesAggregationTest.java
@@ -33,12 +33,12 @@ import org.apache.druid.query.groupby.GroupByQuery;
 import org.apache.druid.query.groupby.GroupByQueryConfig;
 import org.apache.druid.query.groupby.GroupByQueryRunnerTest;
 import org.apache.druid.query.groupby.ResultRow;
-import org.junit.Assert;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+import org.apache.druid.testing.TemporaryFolderExtension;
+import org.junit.jupiter.api.Assertions;
+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 java.io.File;
 import java.util.ArrayList;
@@ -46,11 +46,13 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
-@RunWith(Parameterized.class)
+@ParameterizedClass
+
+@MethodSource("constructorFeeder")
 public class HyperUniquesAggregationTest
 {
-  @Rule
-  public final TemporaryFolder tempFolder = new TemporaryFolder();
+  @RegisterExtension
+  public final TemporaryFolderExtension tempFolder = new TemporaryFolderExtension();
 
   private final GroupByQueryConfig config;
 
@@ -59,7 +61,6 @@ public class HyperUniquesAggregationTest
     this.config = config;
   }
 
-  @Parameterized.Parameters(name = "{0}")
   public static Collection<?> constructorFeeder()
   {
     final List<Object[]> constructors = new ArrayList<>();
@@ -73,7 +74,7 @@ public class HyperUniquesAggregationTest
   public void testIngestAndQuery() throws Exception
   {
     try (
-        final AggregationTestHelper helper = AggregationTestHelper.createGroupByQueryAggregationTestHelper(
+        final AggregationTestHelper helper = AggregationTestHelper.createGroupByQueryAggregationTestHelperWithTemporaryFolderExtension(
             Collections.singletonList(new AggregatorsModule()),
             config,
             tempFolder
@@ -114,8 +115,8 @@ public class HyperUniquesAggregationTest
       );
 
       final ResultRow resultRow = seq.toList().get(0);
-      Assert.assertEquals("index_hll", 3.0, ((Number) resultRow.get(0)).floatValue(), 0.1);
-      Assert.assertEquals("index_unique_count", 3.0, ((Number) resultRow.get(1)).floatValue(), 0.1);
+      Assertions.assertEquals(3.0, ((Number) resultRow.get(0)).floatValue(), 0.1, "index_hll");
+      Assertions.assertEquals(3.0, ((Number) resultRow.get(1)).floatValue(), 0.1, "index_unique_count");
     }
   }
 
@@ -123,7 +124,7 @@ public class HyperUniquesAggregationTest
   public void testIngestAndQueryPrecomputedHll() throws Exception
   {
     try (
-        final AggregationTestHelper helper = AggregationTestHelper.createGroupByQueryAggregationTestHelper(
+        final AggregationTestHelper helper = AggregationTestHelper.createGroupByQueryAggregationTestHelperWithTemporaryFolderExtension(
             Collections.singletonList(new AggregatorsModule()),
             config,
             tempFolder
@@ -164,8 +165,8 @@ public class HyperUniquesAggregationTest
       );
 
       final ResultRow resultRow = seq.toList().get(0);
-      Assert.assertEquals("index_hll", 4.0, ((Number) resultRow.get(0)).floatValue(), 0.1);
-      Assert.assertEquals("index_unique_count", 4.0, ((Number) resultRow.get(1)).floatValue(), 0.1);
+      Assertions.assertEquals(4.0, ((Number) resultRow.get(0)).floatValue(), 0.1, "index_hll");
+      Assertions.assertEquals(4.0, ((Number) resultRow.get(1)).floatValue(), 0.1, "index_unique_count");
     }
   }
 }
diff --git a/processing/src/test/java/org/apache/druid/query/aggregation/mean/DoubleMeanAggregationTest.java b/processing/src/test/java/org/apache/druid/query/aggregation/mean/DoubleMeanAggregationTest.java
index 56330aef6e5..3bf16d9ccf6 100644
--- a/processing/src/test/java/org/apache/druid/query/aggregation/mean/DoubleMeanAggregationTest.java
+++ b/processing/src/test/java/org/apache/druid/query/aggregation/mean/DoubleMeanAggregationTest.java
@@ -23,8 +23,6 @@ import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Iterables;
-import junitparams.JUnitParamsRunner;
-import junitparams.Parameters;
 import org.apache.druid.data.input.Row;
 import org.apache.druid.java.util.common.granularity.Granularities;
 import org.apache.druid.java.util.common.guava.Sequence;
@@ -47,22 +45,22 @@ import org.apache.druid.segment.IncrementalIndexSegment;
 import org.apache.druid.segment.QueryableIndexSegment;
 import org.apache.druid.segment.Segment;
 import org.apache.druid.segment.TestIndex;
+import org.apache.druid.testing.TemporaryFolderExtension;
 import org.apache.druid.timeline.SegmentId;
 import org.easymock.EasyMock;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import java.util.Collections;
 import java.util.List;
 
-@RunWith(JUnitParamsRunner.class)
 public class DoubleMeanAggregationTest
 {
-  public Object[] doVectorizeAndUseVectorApi()
+  public static Object[] doVectorizeAndUseVectorApi()
   {
     return new Object[]{
         new Object[]{false, false},
@@ -71,8 +69,8 @@ public class DoubleMeanAggregationTest
     };
   }
 
-  @Rule
-  public final TemporaryFolder tempFolder = new TemporaryFolder();
+  @RegisterExtension
+  public final TemporaryFolderExtension tempFolder = new TemporaryFolderExtension();
 
   private final AggregationTestHelper groupByQueryTestHelper;
   private final AggregationTestHelper timeseriesQueryTestHelper;
@@ -83,13 +81,13 @@ public class DoubleMeanAggregationTest
   public DoubleMeanAggregationTest()
   {
 
-    groupByQueryTestHelper = AggregationTestHelper.createGroupByQueryAggregationTestHelper(
+    groupByQueryTestHelper = AggregationTestHelper.createGroupByQueryAggregationTestHelperWithTemporaryFolderExtension(
         Collections.emptyList(),
         new GroupByQueryConfig(),
         tempFolder
     );
 
-    timeseriesQueryTestHelper = AggregationTestHelper.createTimeseriesQueryAggregationTestHelper(
+    timeseriesQueryTestHelper = AggregationTestHelper.createTimeseriesQueryAggregationTestHelperWithTemporaryFolderExtension(
         Collections.emptyList(),
         tempFolder
     );
@@ -105,14 +103,14 @@ public class DoubleMeanAggregationTest
     );
   }
 
-  @After
+  @AfterEach
   public void resetExpressionProcessing()
   {
     ExpressionProcessing.initializeForTests();
   }
 
-  @Test
-  @Parameters(method = "doVectorizeAndUseVectorApi")
+  @ParameterizedTest
+  @MethodSource("doVectorizeAndUseVectorApi")
   public void testBufferAggretatorUsingGroupByQuery(final boolean doVectorize, final boolean useVectorApi)
       throws Exception
   {
@@ -137,13 +135,13 @@ public class DoubleMeanAggregationTest
     Sequence<ResultRow> seq = groupByQueryTestHelper.runQueryOnSegmentsObjs(segments, query);
     Row result = Iterables.getOnlyElement(seq.toList()).toMapBasedRow(query);
 
-    Assert.assertEquals(6.2d, result.getMetric("meanOnDouble").doubleValue(), 0.0001d);
-    Assert.assertEquals(6.2d, result.getMetric("meanOnString").doubleValue(), 0.0001d);
-    Assert.assertEquals(4.1333d, result.getMetric("meanOnMultiValue").doubleValue(), 0.0001d);
+    Assertions.assertEquals(6.2d, result.getMetric("meanOnDouble").doubleValue(), 0.0001d);
+    Assertions.assertEquals(6.2d, result.getMetric("meanOnString").doubleValue(), 0.0001d);
+    Assertions.assertEquals(4.1333d, result.getMetric("meanOnMultiValue").doubleValue(), 0.0001d);
   }
 
-  @Test
-  @Parameters(method = "doVectorizeAndUseVectorApi")
+  @ParameterizedTest
+  @MethodSource("doVectorizeAndUseVectorApi")
   public void testVectorAggretatorUsingGroupByQueryOnDoubleColumn(
       final boolean doVectorize,
       final boolean useVectorApi
@@ -169,11 +167,11 @@ public class DoubleMeanAggregationTest
     Sequence<ResultRow> seq = groupByQueryTestHelper.runQueryOnSegmentsObjs(segments, query);
     Row result = Iterables.getOnlyElement(seq.toList()).toMapBasedRow(query);
 
-    Assert.assertEquals(6.2d, result.getMetric("meanOnDouble").doubleValue(), 0.0001d);
+    Assertions.assertEquals(6.2d, result.getMetric("meanOnDouble").doubleValue(), 0.0001d);
   }
 
-  @Test
-  @Parameters(method = "doVectorizeAndUseVectorApi")
+  @ParameterizedTest
+  @MethodSource("doVectorizeAndUseVectorApi")
   public void testVectorAggretatorUsingGroupByQueryOnDoubleColumnOnBiggerSegments(
       final boolean doVectorize,
       final boolean useVectorApi
@@ -197,11 +195,11 @@ public class DoubleMeanAggregationTest
 
     Sequence<ResultRow> seq = groupByQueryTestHelper.runQueryOnSegmentsObjs(biggerSegments, query);
     Row result = Iterables.getOnlyElement(seq.toList()).toMapBasedRow(query);
-    Assert.assertEquals(51.0d, result.getMetric("meanOnDouble").doubleValue(), 0.0001d);
+    Assertions.assertEquals(51.0d, result.getMetric("meanOnDouble").doubleValue(), 0.0001d);
   }
 
-  @Test
-  @Parameters(method = "doVectorizeAndUseVectorApi")
+  @ParameterizedTest
+  @MethodSource("doVectorizeAndUseVectorApi")
   public void testAggretatorUsingTimeseriesQuery(final boolean doVectorize, final boolean useVectorApi)
       throws Exception
   {
@@ -232,9 +230,9 @@ public class DoubleMeanAggregationTest
     Sequence seq = timeseriesQueryTestHelper.runQueryOnSegmentsObjs(segments, query);
     TimeseriesResultValue result = ((Result<TimeseriesResultValue>) Iterables.getOnlyElement(seq.toList())).getValue();
 
-    Assert.assertEquals(6.2d, result.getDoubleMetric("meanOnDouble").doubleValue(), 0.0001d);
-    Assert.assertEquals(6.2d, result.getDoubleMetric("meanOnString").doubleValue(), 0.0001d);
-    Assert.assertEquals(4.1333d, result.getDoubleMetric("meanOnMultiValue").doubleValue(), 0.0001d);
+    Assertions.assertEquals(6.2d, result.getDoubleMetric("meanOnDouble").doubleValue(), 0.0001d);
+    Assertions.assertEquals(6.2d, result.getDoubleMetric("meanOnString").doubleValue(), 0.0001d);
+    Assertions.assertEquals(4.1333d, result.getDoubleMetric("meanOnMultiValue").doubleValue(), 0.0001d);
   }
 
   @Test
@@ -251,20 +249,20 @@ public class DoubleMeanAggregationTest
     DoubleMeanAggregatorFactory aggregatorFactory = new DoubleMeanAggregatorFactory("name", "fieldName");
     AggregatorAndSize aggregatorAndSize = aggregatorFactory.factorizeWithSize(colSelectorFactory);
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         aggregatorFactory.getMaxIntermediateSize(),
         aggregatorAndSize.getInitialSizeBytes()
     );
-    Assert.assertTrue(aggregatorAndSize.getAggregator() instanceof DoubleMeanAggregator);
+    Assertions.assertTrue(aggregatorAndSize.getAggregator() instanceof DoubleMeanAggregator);
     Aggregator aggregator = aggregatorAndSize.getAggregator();
     for (int i = 0; i < values.length; ++i) {
       long sizeDelta = aggregator.aggregateWithSize();
-      Assert.assertEquals(0L, sizeDelta);
+      Assertions.assertEquals(0L, sizeDelta);
       columnValueSelector.increment();
     }
 
     DoubleMeanHolder meanHolder = (DoubleMeanHolder) aggregator.get();
-    Assert.assertEquals(2.0, meanHolder.mean(), 0.0);
+    Assertions.assertEquals(2.0, meanHolder.mean(), 0.0);
   }
 
   private static void initializeExpressionProcessing(final boolean useVectorApi)
diff --git a/processing/src/test/java/org/apache/druid/query/aggregation/post/FinalizingFieldAccessPostAggregatorTest.java b/processing/src/test/java/org/apache/druid/query/aggregation/post/FinalizingFieldAccessPostAggregatorTest.java
index 2b0bc7a120c..8c7b514f5a4 100644
--- a/processing/src/test/java/org/apache/druid/query/aggregation/post/FinalizingFieldAccessPostAggregatorTest.java
+++ b/processing/src/test/java/org/apache/druid/query/aggregation/post/FinalizingFieldAccessPostAggregatorTest.java
@@ -50,11 +50,11 @@ import org.apache.druid.segment.TestHelper;
 import org.apache.druid.segment.column.ColumnType;
 import org.apache.druid.segment.column.RowSignature;
 import org.apache.druid.testing.InitializedNullHandlingTest;
+import org.apache.druid.testing.TemporaryFolderExtension;
 import org.easymock.EasyMock;
-import org.junit.Assert;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
 
 import java.io.File;
 import java.io.IOException;
@@ -66,10 +66,10 @@ import java.util.Map;
 
 public class FinalizingFieldAccessPostAggregatorTest extends InitializedNullHandlingTest
 {
-  @Rule
-  public final TemporaryFolder tempFoler = new TemporaryFolder();
+  @RegisterExtension
+  public final TemporaryFolderExtension tempFoler = new TemporaryFolderExtension();
 
-  @Test(expected = UnsupportedOperationException.class)
+  @Test
   public void testComputeWithoutFinalizing()
   {
     String aggName = "rows";
@@ -82,7 +82,7 @@ public class FinalizingFieldAccessPostAggregatorTest extends InitializedNullHand
     metricValues.put(aggName, agg.get());
 
     FinalizingFieldAccessPostAggregator postAgg = new FinalizingFieldAccessPostAggregator("final_rows", aggName);
-    Assert.assertEquals(3L, postAgg.compute(metricValues));
+    Assertions.assertThrows(UnsupportedOperationException.class, () -> postAgg.compute(metricValues));
   }
 
   @Test
@@ -100,12 +100,12 @@ public class FinalizingFieldAccessPostAggregatorTest extends InitializedNullHand
     );
 
     // Check that the class matches exactly; see https://github.com/apache/druid/issues/6063
-    Assert.assertEquals(FinalizingFieldAccessPostAggregator.class, postAgg.getClass());
+    Assertions.assertEquals(FinalizingFieldAccessPostAggregator.class, postAgg.getClass());
 
     Map<String, Object> metricValues = new HashMap<>();
     metricValues.put(aggName, "test");
 
-    Assert.assertEquals(3L, postAgg.compute(metricValues));
+    Assertions.assertEquals(3L, postAgg.compute(metricValues));
     EasyMock.verify(aggFactory);
   }
 
@@ -131,7 +131,7 @@ public class FinalizingFieldAccessPostAggregatorTest extends InitializedNullHand
 
     ArithmeticPostAggregator arithmeticPostAggregator = new ArithmeticPostAggregator("add", "+", postAggsList);
 
-    Assert.assertEquals(9.0, arithmeticPostAggregator.compute(metricValues));
+    Assertions.assertEquals(9.0, arithmeticPostAggregator.compute(metricValues));
     EasyMock.verify();
   }
 
@@ -170,7 +170,7 @@ public class FinalizingFieldAccessPostAggregatorTest extends InitializedNullHand
     computedValues.add(postAgg.compute(ImmutableMap.of(aggName, "test_val4")));
 
     Collections.sort(computedValues, postAgg.getComparator());
-    Assert.assertArrayEquals(new Object[]{3L, 10L, 21L, null}, computedValues.toArray(new Object[0]));
+    Assertions.assertArrayEquals(new Object[]{3L, 10L, 21L, null}, computedValues.toArray(new Object[0]));
     EasyMock.verify();
   }
 
@@ -196,7 +196,7 @@ public class FinalizingFieldAccessPostAggregatorTest extends InitializedNullHand
     computedValues.add(postAgg.compute(ImmutableMap.of("joe", "test_val4")));
     Collections.sort(computedValues, postAgg.getComparator());
 
-    Assert.assertArrayEquals(
+    Assertions.assertArrayEquals(
         new Object[]{null, "test_val1", "test_val2", "test_val4"},
         computedValues.toArray(new Object[0])
     );
@@ -208,7 +208,7 @@ public class FinalizingFieldAccessPostAggregatorTest extends InitializedNullHand
   public void testIngestAndQueryWithArithmeticPostAggregator() throws Exception
   {
     try (
-        final AggregationTestHelper helper = AggregationTestHelper.createGroupByQueryAggregationTestHelper(
+        final AggregationTestHelper helper = AggregationTestHelper.createGroupByQueryAggregationTestHelperWithTemporaryFolderExtension(
             Collections.singletonList(new AggregatorsModule()),
             GroupByQueryRunnerTest.testConfigs().get(0),
             tempFoler
@@ -258,9 +258,9 @@ public class FinalizingFieldAccessPostAggregatorTest extends InitializedNullHand
       );
 
       final ResultRow resultRow = seq.toList().get(0);
-      Assert.assertEquals("hll_market", 3.0, ((Number) resultRow.get(0)).floatValue(), 0.1);
-      Assert.assertEquals("hll_quality", 9.0, ((Number) resultRow.get(1)).floatValue(), 0.1);
-      Assert.assertEquals("uniq_add", 12.0, ((Number) resultRow.get(2)).floatValue(), 0.1);
+      Assertions.assertEquals(3.0, ((Number) resultRow.get(0)).floatValue(), 0.1, "hll_market");
+      Assertions.assertEquals(9.0, ((Number) resultRow.get(1)).floatValue(), 0.1, "hll_quality");
+      Assertions.assertEquals(12.0, ((Number) resultRow.get(2)).floatValue(), 0.1, "uniq_add");
     }
   }
 
@@ -272,7 +272,7 @@ public class FinalizingFieldAccessPostAggregatorTest extends InitializedNullHand
         ImmutableMap.of("bar", new CountAggregatorFactory("bar"))
     );
     final ObjectMapper objectMapper = TestHelper.makeJsonMapper();
-    Assert.assertEquals(
+    Assertions.assertEquals(
         original,
         objectMapper.readValue(objectMapper.writeValueAsString(decorated), PostAggregator.class)
     );
@@ -296,7 +296,7 @@ public class FinalizingFieldAccessPostAggregatorTest extends InitializedNullHand
               )
               .build();
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         RowSignature.builder()
                     .addTimeColumn()
                     .add("count", ColumnType.LONG)
diff --git a/processing/src/test/java/org/apache/druid/query/aggregation/simd/SimdDoubleMeanVectorAggregatorTest.java b/processing/src/test/java/org/apache/druid/query/aggregation/simd/SimdDoubleMeanVectorAggregatorTest.java
index 2a9bcc12e42..2489e60a30b 100644
--- a/processing/src/test/java/org/apache/druid/query/aggregation/simd/SimdDoubleMeanVectorAggregatorTest.java
+++ b/processing/src/test/java/org/apache/druid/query/aggregation/simd/SimdDoubleMeanVectorAggregatorTest.java
@@ -25,8 +25,8 @@ import org.apache.druid.query.aggregation.mean.DoubleMeanVectorAggregator;
 import org.apache.druid.query.aggregation.simd.SimdAggregatorTestHelpers.FakeVectorValueSelector;
 import org.apache.druid.query.aggregation.simd.SimdAggregatorTestHelpers.NullPattern;
 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.nio.ByteBuffer;
 
@@ -109,18 +109,18 @@ public class SimdDoubleMeanVectorAggregatorTest extends InitializedNullHandlingT
   {
     final DoubleMeanHolder expected = DoubleMeanHolder.get(expectedBuf, position);
     final DoubleMeanHolder actual = DoubleMeanHolder.get(actualBuf, position);
-    Assert.assertEquals(msg + " (count)", count(expected), count(actual));
-    Assert.assertEquals(
-        msg + " (sum)",
+    Assertions.assertEquals(count(expected), count(actual), msg + " (count)");
+    Assertions.assertEquals(
         sum(expected),
         sum(actual),
-        Math.max(Math.abs(sum(expected)) * 1e-12, DELTA)
+        Math.max(Math.abs(sum(expected)) * 1e-12, DELTA),
+        msg + " (sum)"
     );
-    Assert.assertEquals(
-        msg + " (mean)",
+    Assertions.assertEquals(
         expected.mean(),
         actual.mean(),
-        Math.max(Math.abs(expected.mean()) * 1e-12, DELTA)
+        Math.max(Math.abs(expected.mean()) * 1e-12, DELTA),
+        msg + " (mean)"
     );
   }
 
diff --git a/processing/src/test/java/org/apache/druid/query/aggregation/simd/SimdMinMaxVectorAggregatorTest.java b/processing/src/test/java/org/apache/druid/query/aggregation/simd/SimdMinMaxVectorAggregatorTest.java
index 256021b24ef..8ed58e74fda 100644
--- a/processing/src/test/java/org/apache/druid/query/aggregation/simd/SimdMinMaxVectorAggregatorTest.java
+++ b/processing/src/test/java/org/apache/druid/query/aggregation/simd/SimdMinMaxVectorAggregatorTest.java
@@ -29,8 +29,8 @@ import org.apache.druid.query.aggregation.LongMinVectorAggregator;
 import org.apache.druid.query.aggregation.simd.SimdAggregatorTestHelpers.FakeVectorValueSelector;
 import org.apache.druid.query.aggregation.simd.SimdAggregatorTestHelpers.NullPattern;
 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.nio.ByteBuffer;
 
@@ -159,7 +159,7 @@ public class SimdMinMaxVectorAggregatorTest extends InitializedNullHandlingTest
         scalar.aggregate(scalarBuf, position, startRow, endRow);
         simd.aggregate(simdBuf, position, startRow, endRow);
       }
-      Assert.assertEquals(msg, scalarBuf.getLong(position), simdBuf.getLong(position));
+      Assertions.assertEquals(scalarBuf.getLong(position), simdBuf.getLong(position), msg);
     } else {
       long expected = identity;
       boolean anyNonNull = false;
@@ -180,8 +180,8 @@ public class SimdMinMaxVectorAggregatorTest extends InitializedNullHandlingTest
         simd.init(simdBuf, position);
         reported = simd.aggregate(simdBuf, position, startRow, endRow, nulls);
       }
-      Assert.assertEquals(msg + " (anyNonNull)", anyNonNull, reported);
-      Assert.assertEquals(msg, expected, simdBuf.getLong(position));
+      Assertions.assertEquals(anyNonNull, reported, msg + " (anyNonNull)");
+      Assertions.assertEquals(expected, simdBuf.getLong(position), msg);
     }
   }
 
@@ -225,7 +225,7 @@ public class SimdMinMaxVectorAggregatorTest extends InitializedNullHandlingTest
         simd.aggregate(simdBuf, position, startRow, endRow);
       }
       // min/max produces a value that was present in the input -- exact equality is fine.
-      Assert.assertEquals(msg, scalarBuf.getDouble(position), simdBuf.getDouble(position), 0.0);
+      Assertions.assertEquals(scalarBuf.getDouble(position), simdBuf.getDouble(position), 0.0, msg);
     } else {
       double expected = identity;
       boolean anyNonNull = false;
@@ -246,8 +246,8 @@ public class SimdMinMaxVectorAggregatorTest extends InitializedNullHandlingTest
         simd.init(simdBuf, position);
         reported = simd.aggregate(simdBuf, position, startRow, endRow, nulls);
       }
-      Assert.assertEquals(msg + " (anyNonNull)", anyNonNull, reported);
-      Assert.assertEquals(msg, expected, simdBuf.getDouble(position), 0.0);
+      Assertions.assertEquals(anyNonNull, reported, msg + " (anyNonNull)");
+      Assertions.assertEquals(expected, simdBuf.getDouble(position), 0.0, msg);
     }
   }
 
@@ -290,7 +290,7 @@ public class SimdMinMaxVectorAggregatorTest extends InitializedNullHandlingTest
         scalar.aggregate(scalarBuf, position, startRow, endRow);
         simd.aggregate(simdBuf, position, startRow, endRow);
       }
-      Assert.assertEquals(msg, scalarBuf.getFloat(position), simdBuf.getFloat(position), 0.0f);
+      Assertions.assertEquals(scalarBuf.getFloat(position), simdBuf.getFloat(position), 0.0f, msg);
     } else {
       float expected = identity;
       boolean anyNonNull = false;
@@ -311,8 +311,8 @@ public class SimdMinMaxVectorAggregatorTest extends InitializedNullHandlingTest
         simd.init(simdBuf, position);
         reported = simd.aggregate(simdBuf, position, startRow, endRow, nulls);
       }
-      Assert.assertEquals(msg + " (anyNonNull)", anyNonNull, reported);
-      Assert.assertEquals(msg, expected, simdBuf.getFloat(position), 0.0f);
+      Assertions.assertEquals(anyNonNull, reported, msg + " (anyNonNull)");
+      Assertions.assertEquals(expected, simdBuf.getFloat(position), 0.0f, msg);
     }
   }
 
diff --git a/processing/src/test/java/org/apache/druid/query/aggregation/simd/SimdSumVectorAggregatorTest.java b/processing/src/test/java/org/apache/druid/query/aggregation/simd/SimdSumVectorAggregatorTest.java
index d4fbd27f399..016653ef336 100644
--- a/processing/src/test/java/org/apache/druid/query/aggregation/simd/SimdSumVectorAggregatorTest.java
+++ b/processing/src/test/java/org/apache/druid/query/aggregation/simd/SimdSumVectorAggregatorTest.java
@@ -26,8 +26,8 @@ import org.apache.druid.query.aggregation.LongSumVectorAggregator;
 import org.apache.druid.query.aggregation.simd.SimdAggregatorTestHelpers.FakeVectorValueSelector;
 import org.apache.druid.query.aggregation.simd.SimdAggregatorTestHelpers.NullPattern;
 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.nio.ByteBuffer;
 
@@ -119,7 +119,7 @@ public class SimdSumVectorAggregatorTest extends InitializedNullHandlingTest
       simd.init(simdBuf, position);
       scalar.aggregate(scalarBuf, position, startRow, endRow);
       simd.aggregate(simdBuf, position, startRow, endRow);
-      Assert.assertEquals(msg, scalarBuf.getLong(position), simdBuf.getLong(position));
+      Assertions.assertEquals(scalarBuf.getLong(position), simdBuf.getLong(position), msg);
     } else {
       long expected = 0;
       boolean anyNonNull = false;
@@ -132,9 +132,9 @@ public class SimdSumVectorAggregatorTest extends InitializedNullHandlingTest
       final ByteBuffer simdBuf = ByteBuffer.allocate(position + Long.BYTES);
       simd.init(simdBuf, position);
       final boolean reported = simd.aggregate(simdBuf, position, startRow, endRow, nulls);
-      Assert.assertEquals(msg + " (anyNonNull)", anyNonNull, reported);
+      Assertions.assertEquals(anyNonNull, reported, msg + " (anyNonNull)");
       if (reported) {
-        Assert.assertEquals(msg, expected, simdBuf.getLong(position));
+        Assertions.assertEquals(expected, simdBuf.getLong(position), msg);
       }
     }
   }
@@ -168,11 +168,11 @@ public class SimdSumVectorAggregatorTest extends InitializedNullHandlingTest
       simd.init(simdBuf, position);
       scalar.aggregate(scalarBuf, position, startRow, endRow);
       simd.aggregate(simdBuf, position, startRow, endRow);
-      Assert.assertEquals(
-          msg,
+      Assertions.assertEquals(
           scalarBuf.getDouble(position),
           simdBuf.getDouble(position),
-          Math.max(Math.abs(scalarBuf.getDouble(position)) * 1e-12, 1e-12)
+          Math.max(Math.abs(scalarBuf.getDouble(position)) * 1e-12, 1e-12),
+          msg
       );
     } else {
       double expected = 0;
@@ -186,13 +186,13 @@ public class SimdSumVectorAggregatorTest extends InitializedNullHandlingTest
       final ByteBuffer simdBuf = ByteBuffer.allocate(position + Double.BYTES);
       simd.init(simdBuf, position);
       final boolean reported = simd.aggregate(simdBuf, position, startRow, endRow, nulls);
-      Assert.assertEquals(msg + " (anyNonNull)", anyNonNull, reported);
+      Assertions.assertEquals(anyNonNull, reported, msg + " (anyNonNull)");
       if (reported) {
-        Assert.assertEquals(
-            msg,
+        Assertions.assertEquals(
             expected,
             simdBuf.getDouble(position),
-            Math.max(Math.abs(expected) * 1e-12, 1e-12)
+            Math.max(Math.abs(expected) * 1e-12, 1e-12),
+            msg
         );
       }
     }
@@ -227,11 +227,11 @@ public class SimdSumVectorAggregatorTest extends InitializedNullHandlingTest
       simd.init(simdBuf, position);
       scalar.aggregate(scalarBuf, position, startRow, endRow);
       simd.aggregate(simdBuf, position, startRow, endRow);
-      Assert.assertEquals(
-          msg,
+      Assertions.assertEquals(
           scalarBuf.getFloat(position),
           simdBuf.getFloat(position),
-          Math.max(Math.abs(scalarBuf.getFloat(position)) * 1e-5f, 1e-5f)
+          Math.max(Math.abs(scalarBuf.getFloat(position)) * 1e-5f, 1e-5f),
+          msg
       );
     } else {
       float expected = 0;
@@ -245,13 +245,13 @@ public class SimdSumVectorAggregatorTest extends InitializedNullHandlingTest
       final ByteBuffer simdBuf = ByteBuffer.allocate(position + Float.BYTES);
       simd.init(simdBuf, position);
       final boolean reported = simd.aggregate(simdBuf, position, startRow, endRow, nulls);
-      Assert.assertEquals(msg + " (anyNonNull)", anyNonNull, reported);
+      Assertions.assertEquals(anyNonNull, reported, msg + " (anyNonNull)");
       if (reported) {
-        Assert.assertEquals(
-            msg,
+        Assertions.assertEquals(
             expected,
             simdBuf.getFloat(position),
-            Math.max(Math.abs(expected) * 1e-5f, 1e-5f)
+            Math.max(Math.abs(expected) * 1e-5f, 1e-5f),
+            msg
         );
       }
     }
diff --git a/processing/src/test/java/org/apache/druid/query/context/ResponseContextTest.java b/processing/src/test/java/org/apache/druid/query/context/ResponseContextTest.java
index 0ae182b2f30..d648c890c66 100644
--- a/processing/src/test/java/org/apache/druid/query/context/ResponseContextTest.java
+++ b/processing/src/test/java/org/apache/druid/query/context/ResponseContextTest.java
@@ -32,8 +32,8 @@ import org.apache.druid.query.context.ResponseContext.Key;
 import org.apache.druid.query.context.ResponseContext.Keys;
 import org.apache.druid.query.context.ResponseContext.StringKey;
 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.io.IOException;
 import java.util.Arrays;
@@ -60,22 +60,31 @@ public class ResponseContextTest
   static final Key UNREGISTERED_KEY = new StringKey(
       "unregistered-key", true, true);
 
-  @Test(expected = IllegalStateException.class)
+  @Test
   public void putISETest()
   {
-    ResponseContext.createEmpty().put(UNREGISTERED_KEY, new Object());
+    Assertions.assertThrows(
+        IllegalStateException.class,
+        () -> ResponseContext.createEmpty().put(UNREGISTERED_KEY, new Object())
+    );
   }
 
-  @Test(expected = IllegalStateException.class)
+  @Test
   public void addISETest()
   {
-    ResponseContext.createEmpty().add(UNREGISTERED_KEY, new Object());
+    Assertions.assertThrows(
+        IllegalStateException.class,
+        () -> ResponseContext.createEmpty().add(UNREGISTERED_KEY, new Object())
+    );
   }
 
-  @Test(expected = IllegalArgumentException.class)
+  @Test
   public void registerKeyIAETest()
   {
-    Keys.INSTANCE.registerKey(Keys.NUM_SCANNED_ROWS);
+    Assertions.assertThrows(
+        IllegalArgumentException.class,
+        () -> Keys.INSTANCE.registerKey(Keys.NUM_SCANNED_ROWS)
+    );
   }
 
   @Test
@@ -83,9 +92,9 @@ public class ResponseContextTest
   {
     final ResponseContext ctx = ResponseContext.createEmpty();
     ctx.putEntityTag("dummy-etag");
-    Assert.assertEquals("dummy-etag", ctx.getEntityTag());
+    Assertions.assertEquals("dummy-etag", ctx.getEntityTag());
     ctx.putEntityTag("new-dummy-etag");
-    Assert.assertEquals("new-dummy-etag", ctx.getEntityTag());
+    Assertions.assertEquals("new-dummy-etag", ctx.getEntityTag());
   }
 
   private static final Interval INTERVAL_01 = Intervals.of("2019-01-01/P1D");
@@ -97,12 +106,12 @@ public class ResponseContextTest
   {
     final ResponseContext ctx = ResponseContext.createEmpty();
     ctx.putUncoveredIntervals(Collections.singletonList(INTERVAL_01), false);
-    Assert.assertArrayEquals(
+    Assertions.assertArrayEquals(
         Collections.singletonList(INTERVAL_01).toArray(),
         ctx.getUncoveredIntervals().toArray()
     );
     ctx.add(Keys.UNCOVERED_INTERVALS, Arrays.asList(INTERVAL_12, INTERVAL_23));
-    Assert.assertArrayEquals(
+    Assertions.assertArrayEquals(
         Arrays.asList(INTERVAL_01, INTERVAL_12, INTERVAL_23).toArray(),
         ctx.getUncoveredIntervals().toArray()
     );
@@ -119,7 +128,7 @@ public class ResponseContextTest
     ctx.addRemainingResponse(queryId2, 4);
     ctx.addRemainingResponse(queryId, -1);
     ctx.addRemainingResponse(queryId, -2);
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableMap.of(queryId, 0, queryId2, 4),
         ctx.get(Keys.REMAINING_RESPONSES_FROM_QUERY_SERVERS)
     );
@@ -131,14 +140,14 @@ public class ResponseContextTest
     final ResponseContext ctx = ResponseContext.createEmpty();
     final SegmentDescriptor sd01 = new SegmentDescriptor(INTERVAL_01, "01", 0);
     ctx.addMissingSegments(Collections.singletonList(sd01));
-    Assert.assertArrayEquals(
+    Assertions.assertArrayEquals(
         Collections.singletonList(sd01).toArray(),
         ctx.getMissingSegments().toArray()
     );
     final SegmentDescriptor sd12 = new SegmentDescriptor(INTERVAL_12, "12", 1);
     final SegmentDescriptor sd23 = new SegmentDescriptor(INTERVAL_23, "23", 2);
     ctx.addMissingSegments(Arrays.asList(sd12, sd23));
-    Assert.assertArrayEquals(
+    Assertions.assertArrayEquals(
         Arrays.asList(sd01, sd12, sd23).toArray(),
         ctx.getMissingSegments().toArray()
     );
@@ -148,22 +157,22 @@ public class ResponseContextTest
   public void initScannedRowsTest()
   {
     final ResponseContext ctx = ResponseContext.createEmpty();
-    Assert.assertNull(ctx.getRowScanCount());
+    Assertions.assertNull(ctx.getRowScanCount());
     ctx.initializeRowScanCount();
-    Assert.assertEquals((Long) 0L, ctx.getRowScanCount());
+    Assertions.assertEquals((Long) 0L, ctx.getRowScanCount());
   }
 
   @Test
   public void mergeScannedRowsTest()
   {
     final ResponseContext ctx = ResponseContext.createEmpty();
-    Assert.assertNull(ctx.getRowScanCount());
+    Assertions.assertNull(ctx.getRowScanCount());
     ctx.addRowScanCount(0L);
-    Assert.assertEquals((Long) 0L, ctx.getRowScanCount());
+    Assertions.assertEquals((Long) 0L, ctx.getRowScanCount());
     ctx.addRowScanCount(1L);
-    Assert.assertEquals((Long) 1L, ctx.getRowScanCount());
+    Assertions.assertEquals((Long) 1L, ctx.getRowScanCount());
     ctx.addRowScanCount(3L);
-    Assert.assertEquals((Long) 4L, ctx.getRowScanCount());
+    Assertions.assertEquals((Long) 4L, ctx.getRowScanCount());
   }
 
   @Test
@@ -171,11 +180,11 @@ public class ResponseContextTest
   {
     final ResponseContext ctx = ResponseContext.createEmpty();
     ctx.add(Keys.UNCOVERED_INTERVALS_OVERFLOWED, false);
-    Assert.assertEquals(false, ctx.get(Keys.UNCOVERED_INTERVALS_OVERFLOWED));
+    Assertions.assertEquals(false, ctx.get(Keys.UNCOVERED_INTERVALS_OVERFLOWED));
     ctx.add(Keys.UNCOVERED_INTERVALS_OVERFLOWED, true);
-    Assert.assertEquals(true, ctx.get(Keys.UNCOVERED_INTERVALS_OVERFLOWED));
+    Assertions.assertEquals(true, ctx.get(Keys.UNCOVERED_INTERVALS_OVERFLOWED));
     ctx.add(Keys.UNCOVERED_INTERVALS_OVERFLOWED, false);
-    Assert.assertEquals(true, ctx.get(Keys.UNCOVERED_INTERVALS_OVERFLOWED));
+    Assertions.assertEquals(true, ctx.get(Keys.UNCOVERED_INTERVALS_OVERFLOWED));
   }
 
   @Test
@@ -194,19 +203,19 @@ public class ResponseContextTest
     ctx2.addRowScanCount(2L);
 
     ctx1.merge(ctx2);
-    Assert.assertEquals("dummy-etag-2", ctx1.getEntityTag());
-    Assert.assertEquals((Long) 3L, ctx1.getRowScanCount());
-    Assert.assertArrayEquals(
+    Assertions.assertEquals("dummy-etag-2", ctx1.getEntityTag());
+    Assertions.assertEquals((Long) 3L, ctx1.getRowScanCount());
+    Assertions.assertArrayEquals(
         Arrays.asList(INTERVAL_01, INTERVAL_12).toArray(),
         ctx1.getUncoveredIntervals().toArray()
     );
-    Assert.assertArrayEquals(
+    Assertions.assertArrayEquals(
         Collections.singletonList(sd01).toArray(),
         ctx1.getMissingSegments().toArray()
     );
   }
 
-  @Test(expected = IllegalStateException.class)
+  @Test
   public void mergeISETest()
   {
     final ResponseContext ctx = new ResponseContext()
@@ -217,7 +226,7 @@ public class ResponseContextTest
         return ImmutableMap.of(UNREGISTERED_KEY, "non-registered-key");
       }
     };
-    ResponseContext.createEmpty().merge(ctx);
+    Assertions.assertThrows(IllegalStateException.class, () -> ResponseContext.createEmpty().merge(ctx));
   }
 
   @Test
@@ -226,7 +235,7 @@ public class ResponseContextTest
     final ResponseContext ctx1 = ResponseContext.createEmpty();
     ctx1.add(EXTN_STRING_KEY, "string-value");
     final DefaultObjectMapper mapper = new DefaultObjectMapper();
-    Assert.assertEquals(
+    Assertions.assertEquals(
         mapper.writeValueAsString(ImmutableMap.of(
             EXTN_STRING_KEY.getName(),
             "string-value")),
@@ -235,7 +244,7 @@ public class ResponseContextTest
     final ResponseContext ctx2 = ResponseContext.createEmpty(); // Add two non-header fields, and one that will be in the header ctx2.putEntityTag("not in header");
     ctx2.addCpuNanos(100);
     ctx2.add(EXTN_COUNTER_KEY, 100);
-    Assert.assertEquals(
+    Assertions.assertEquals(
         mapper.writeValueAsString(ImmutableMap.of(
             EXTN_COUNTER_KEY.getName(), 100)),
         ctx2.serializeWith(mapper, Integer.MAX_VALUE).getResult());
@@ -254,7 +263,7 @@ public class ResponseContextTest
     ctx.put(EXTN_STRING_KEY, "long-string-that-is-supposed-to-be-removed-from-result");
     final DefaultObjectMapper objectMapper = new DefaultObjectMapper();
     final ResponseContext.SerializationResult res1 = ctx.serializeWith(objectMapper, Integer.MAX_VALUE);
-    Assert.assertEquals(ctx.getDelegate(), deserializeContext(res1.getResult(), objectMapper));
+    Assertions.assertEquals(ctx.getDelegate(), deserializeContext(res1.getResult(), objectMapper));
     final ResponseContext ctxCopy = ResponseContext.createEmpty();
     ctxCopy.merge(ctx);
     final int target = EXTN_COUNTER_KEY.getName().length() + 3 +
@@ -263,7 +272,7 @@ public class ResponseContextTest
     final ResponseContext.SerializationResult res2 = ctx.serializeWith(objectMapper, target);
     ctxCopy.remove(EXTN_STRING_KEY);
     ctxCopy.put(Keys.TRUNCATED, true);
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ctxCopy.getDelegate(),
         deserializeContext(res2.getResult(), objectMapper)
     );
@@ -289,8 +298,8 @@ public class ResponseContextTest
     final ObjectMapper mapper = new DefaultObjectMapper();
     String serialized = mapper.writeValueAsString(bogus);
     ResponseContext ctx = ResponseContext.deserialize(serialized, mapper);
-    Assert.assertEquals(1, ctx.getDelegate().size());
-    Assert.assertEquals("eTag", ctx.get(Keys.ETAG));
+    Assertions.assertEquals(1, ctx.getDelegate().size());
+    Assertions.assertEquals("eTag", ctx.get(Keys.ETAG));
   }
 
   // Interval value for the test. Must match the deserialized value.
@@ -319,7 +328,7 @@ public class ResponseContextTest
     );
     final DefaultObjectMapper objectMapper = new DefaultObjectMapper();
     final ResponseContext.SerializationResult res1 = ctx.serializeWith(objectMapper, Integer.MAX_VALUE);
-    Assert.assertEquals(ctx.getDelegate(),
+    Assertions.assertEquals(ctx.getDelegate(),
         deserializeContext(res1.getResult(), objectMapper)
     );
     final int maxLen = INTERVAL_LEN * 4 + Keys.UNCOVERED_INTERVALS.getName().length() + 4 +
@@ -330,7 +339,7 @@ public class ResponseContextTest
     // length.
     ctxCopy.put(Keys.UNCOVERED_INTERVALS, Arrays.asList(interval(1), interval(2), interval(3)));
     ctxCopy.put(Keys.TRUNCATED, true);
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ctxCopy.getDelegate(),
         deserializeContext(res2.getResult(), objectMapper)
     );
@@ -350,13 +359,13 @@ public class ResponseContextTest
         ),
         mapper
     );
-    Assert.assertEquals("string-value", ctx.getEntityTag());
-    Assert.assertEquals((Long) 100L, ctx.getRowScanCount());
-    Assert.assertEquals((Long) 100000L, ctx.getCpuNanos());
+    Assertions.assertEquals("string-value", ctx.getEntityTag());
+    Assertions.assertEquals((Long) 100L, ctx.getRowScanCount());
+    Assertions.assertEquals((Long) 100000L, ctx.getCpuNanos());
     ctx.addRowScanCount(10L);
-    Assert.assertEquals((Long) 110L, ctx.getRowScanCount());
+    Assertions.assertEquals((Long) 110L, ctx.getRowScanCount());
     ctx.addCpuNanos(100L);
-    Assert.assertEquals((Long) 100100L, ctx.getCpuNanos());
+    Assertions.assertEquals((Long) 100100L, ctx.getCpuNanos());
   }
 
   @Test
@@ -371,9 +380,9 @@ public class ResponseContextTest
     ctxFinal.add(EXTN_STRING_KEY, "old-string-value");
     ctxFinal.add(EXTN_COUNTER_KEY, 1L);
     ctxFinal.merge(ctx);
-    Assert.assertEquals("etag", ctxFinal.getEntityTag());
-    Assert.assertEquals("string-value", ctxFinal.get(EXTN_STRING_KEY));
-    Assert.assertEquals(1L + 2L, ctxFinal.get(EXTN_COUNTER_KEY));
+    Assertions.assertEquals("etag", ctxFinal.getEntityTag());
+    Assertions.assertEquals("string-value", ctxFinal.get(EXTN_STRING_KEY));
+    Assertions.assertEquals(1L + 2L, ctxFinal.get(EXTN_COUNTER_KEY));
   }
 
   @Test
@@ -382,6 +391,6 @@ public class ResponseContextTest
     final ResponseContext ctx = ResponseContext.createEmpty();
     ctx.putEntityTag("etag");
     Map<String, Object> map = ctx.toMap();
-    Assert.assertEquals(map.get(ResponseContext.Keys.ETAG.getName()), "etag");
+    Assertions.assertEquals(map.get(ResponseContext.Keys.ETAG.getName()), "etag");
   }
 }
diff --git a/processing/src/test/java/org/apache/druid/query/datasourcemetadata/DataSourceMetadataQueryTest.java b/processing/src/test/java/org/apache/druid/query/datasourcemetadata/DataSourceMetadataQueryTest.java
index 27dd2bfc8d4..08a7c713485 100644
--- a/processing/src/test/java/org/apache/druid/query/datasourcemetadata/DataSourceMetadataQueryTest.java
+++ b/processing/src/test/java/org/apache/druid/query/datasourcemetadata/DataSourceMetadataQueryTest.java
@@ -50,8 +50,8 @@ import org.apache.druid.timeline.LogicalSegment;
 import org.apache.druid.timeline.SegmentId;
 import org.joda.time.DateTime;
 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.io.IOException;
 import java.util.Arrays;
@@ -72,7 +72,7 @@ public class DataSourceMetadataQueryTest
     String json = JSON_MAPPER.writeValueAsString(query);
     Query<?> serdeQuery = JSON_MAPPER.readValue(json, Query.class);
 
-    Assert.assertEquals(query, serdeQuery);
+    Assertions.assertEquals(query, serdeQuery);
   }
 
   @Test
@@ -107,13 +107,13 @@ public class DataSourceMetadataQueryTest
     );
 
     final QueryContext queryContext = serdeQuery.context();
-    Assert.assertEquals(1, (int) queryContext.getInt(QueryContexts.PRIORITY_KEY));
-    Assert.assertEquals(true, queryContext.getBoolean(QueryContexts.USE_CACHE_KEY));
-    Assert.assertEquals("true", queryContext.getString(QueryContexts.POPULATE_CACHE_KEY));
-    Assert.assertEquals(true, queryContext.getBoolean(QueryContexts.FINALIZE_KEY));
-    Assert.assertEquals(true, queryContext.getBoolean(QueryContexts.USE_CACHE_KEY, false));
-    Assert.assertEquals(true, queryContext.getBoolean(QueryContexts.POPULATE_CACHE_KEY, false));
-    Assert.assertEquals(true, queryContext.getBoolean(QueryContexts.FINALIZE_KEY, false));
+    Assertions.assertEquals(1, (int) queryContext.getInt(QueryContexts.PRIORITY_KEY));
+    Assertions.assertEquals(true, queryContext.getBoolean(QueryContexts.USE_CACHE_KEY));
+    Assertions.assertEquals("true", queryContext.getString(QueryContexts.POPULATE_CACHE_KEY));
+    Assertions.assertEquals(true, queryContext.getBoolean(QueryContexts.FINALIZE_KEY));
+    Assertions.assertEquals(true, queryContext.getBoolean(QueryContexts.USE_CACHE_KEY, false));
+    Assertions.assertEquals(true, queryContext.getBoolean(QueryContexts.POPULATE_CACHE_KEY, false));
+    Assertions.assertEquals(true, queryContext.getBoolean(QueryContexts.FINALIZE_KEY, false));
   }
 
   /**
@@ -161,7 +161,7 @@ public class DataSourceMetadataQueryTest
     DataSourceMetadataResultValue val = results.iterator().next().getValue();
     DateTime maxIngestedEventTime = val.getMaxIngestedEventTime();
 
-    Assert.assertEquals(timestamp, maxIngestedEventTime);
+    Assertions.assertEquals(timestamp, maxIngestedEventTime);
   }
 
   @Test
@@ -190,7 +190,7 @@ public class DataSourceMetadataQueryTest
     DataSourceMetadataResultValue val = results.iterator().next().getValue();
     DateTime maxIngestedEventTime = val.getMaxIngestedEventTime();
 
-    Assert.assertEquals(timestamp, maxIngestedEventTime);
+    Assertions.assertEquals(timestamp, maxIngestedEventTime);
   }
 
   @Test
@@ -275,7 +275,7 @@ public class DataSourceMetadataQueryTest
             )
         );
 
-    Assert.assertEquals(segments.size(), 2);
+    Assertions.assertEquals(segments.size(), 2);
     // should only have the latest segments.
     List<LogicalSegment> expected = Arrays.asList(
         new LogicalSegment()
@@ -309,7 +309,7 @@ public class DataSourceMetadataQueryTest
     );
 
     for (int i = 0; i < segments.size(); i++) {
-      Assert.assertEquals(expected.get(i).getInterval(), segments.get(i).getInterval());
+      Assertions.assertEquals(expected.get(i).getInterval(), segments.get(i).getInterval());
     }
   }
 
@@ -442,11 +442,11 @@ public class DataSourceMetadataQueryTest
         }
     );
 
-    Assert.assertEquals(expected.size(), segments.size());
+    Assertions.assertEquals(expected.size(), segments.size());
 
     for (int i = 0; i < expected.size(); i++) {
-      Assert.assertEquals(expected.get(i).getInterval(), segments.get(i).getInterval());
-      Assert.assertEquals(expected.get(i).getTrueInterval(), segments.get(i).getTrueInterval());
+      Assertions.assertEquals(expected.get(i).getInterval(), segments.get(i).getInterval());
+      Assertions.assertEquals(expected.get(i).getTrueInterval(), segments.get(i).getTrueInterval());
     }
   }
 
@@ -458,7 +458,7 @@ public class DataSourceMetadataQueryTest
         resultValue,
         JacksonUtils.TYPE_REFERENCE_MAP_STRING_OBJECT
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableMap.<String, Object>of("maxIngestedEventTime", "2000-01-01T00:00:00.000Z"),
         resultValueMap
     );
@@ -475,7 +475,7 @@ public class DataSourceMetadataQueryTest
         resultValueMap,
         DataSourceMetadataResultValue.class
     );
-    Assert.assertEquals(DateTimes.of("2000"), resultValue.getMaxIngestedEventTime());
+    Assertions.assertEquals(DateTimes.of("2000"), resultValue.getMaxIngestedEventTime());
   }
 
 }
diff --git a/processing/src/test/java/org/apache/druid/query/groupby/ComplexDimensionGroupByQueryTest.java b/processing/src/test/java/org/apache/druid/query/groupby/ComplexDimensionGroupByQueryTest.java
index 0a17fa45933..2a31147d9d1 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/ComplexDimensionGroupByQueryTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/ComplexDimensionGroupByQueryTest.java
@@ -35,12 +35,12 @@ import org.apache.druid.segment.RowBasedSegment;
 import org.apache.druid.segment.Segment;
 import org.apache.druid.segment.column.ColumnType;
 import org.apache.druid.segment.column.RowSignature;
-import org.junit.Assert;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+import org.apache.druid.testing.TemporaryFolderExtension;
+import org.junit.jupiter.api.Assertions;
+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 java.util.ArrayList;
 import java.util.Collection;
@@ -48,20 +48,22 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
-@RunWith(Parameterized.class)
+@ParameterizedClass
+
+@MethodSource("constructorFeeder")
 public class ComplexDimensionGroupByQueryTest
 {
   private final QueryContexts.Vectorize vectorize;
   private final AggregationTestHelper helper;
   private final List<Segment> segments;
 
-  @Rule
-  public final TemporaryFolder tempFolder = new TemporaryFolder();
+  @RegisterExtension
+  public final TemporaryFolderExtension tempFolder = new TemporaryFolderExtension();
 
   public ComplexDimensionGroupByQueryTest(GroupByQueryConfig config, String vectorize)
   {
     this.vectorize = QueryContexts.Vectorize.fromString(vectorize);
-    this.helper = AggregationTestHelper.createGroupByQueryAggregationTestHelper(
+    this.helper = AggregationTestHelper.createGroupByQueryAggregationTestHelperWithTemporaryFolderExtension(
         Collections.emptyList(),
         config,
         tempFolder
@@ -100,7 +102,6 @@ public class ComplexDimensionGroupByQueryTest
     );
   }
 
-  @Parameterized.Parameters(name = "config = {0}, vectorize = {1}")
   public static Collection<?> constructorFeeder()
   {
     final List<Object[]> constructors = new ArrayList<>();
@@ -138,14 +139,14 @@ public class ComplexDimensionGroupByQueryTest
 
     if (vectorize == QueryContexts.Vectorize.FORCE) {
       // Cannot vectorize group by on complex dimension
-      Assert.assertThrows(
+      Assertions.assertThrows(
           RuntimeException.class,
           () -> helper.runQueryOnSegmentsObjs(segments, groupQuery).toList()
       );
     } else {
       List<ResultRow> resultRows = helper.runQueryOnSegmentsObjs(segments, groupQuery).toList();
 
-      Assert.assertArrayEquals(
+      Assertions.assertArrayEquals(
           new ResultRow[]{
               ResultRow.of(new SerializablePairLongString(1L, "abc"), 4L),
               ResultRow.of(new SerializablePairLongString(1L, "bar"), 1L),
diff --git a/processing/src/test/java/org/apache/druid/query/groupby/GroupByLimitPushDownInsufficientBufferTest.java b/processing/src/test/java/org/apache/druid/query/groupby/GroupByLimitPushDownInsufficientBufferTest.java
index 9e4706d44f5..18c6c478093 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/GroupByLimitPushDownInsufficientBufferTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/GroupByLimitPushDownInsufficientBufferTest.java
@@ -75,10 +75,10 @@ import org.apache.druid.segment.incremental.OnheapIncrementalIndex;
 import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
 import org.apache.druid.testing.InitializedNullHandlingTest;
 import org.apache.druid.timeline.SegmentId;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+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 java.io.File;
 import java.util.ArrayList;
@@ -143,7 +143,7 @@ public class GroupByLimitPushDownInsufficientBufferTest extends InitializedNullH
         .build();
   }
 
-  @Before
+  @BeforeEach
   public void setup() throws Exception
   {
     tmpDir = FileUtils.createTempDir();
@@ -266,8 +266,8 @@ public class GroupByLimitPushDownInsufficientBufferTest extends InitializedNullH
 
     resourceCloser.register(() -> {
       // Verify that all objects have been returned to the pools.
-      Assert.assertEquals(0, mergePool.getOutstandingObjectCount());
-      Assert.assertEquals(0, tooSmallMergePool.getOutstandingObjectCount());
+      Assertions.assertEquals(0, mergePool.getOutstandingObjectCount());
+      Assertions.assertEquals(0, tooSmallMergePool.getOutstandingObjectCount());
     });
 
     final GroupByQueryConfig config = new GroupByQueryConfig()
@@ -369,7 +369,7 @@ public class GroupByLimitPushDownInsufficientBufferTest extends InitializedNullH
     );
   }
 
-  @After
+  @AfterEach
   public void tearDown() throws Exception
   {
     for (IncrementalIndex incrementalIndex : incrementalIndices) {
@@ -486,10 +486,10 @@ public class GroupByLimitPushDownInsufficientBufferTest extends InitializedNullH
         "metA", 150L
     );
 
-    Assert.assertEquals(3, results.size());
-    Assert.assertEquals(expectedRow0, results.get(0));
-    Assert.assertEquals(expectedRow1, results.get(1));
-    Assert.assertEquals(expectedRow2, results.get(2));
+    Assertions.assertEquals(3, results.size());
+    Assertions.assertEquals(expectedRow0, results.get(0));
+    Assertions.assertEquals(expectedRow1, results.get(1));
+    Assertions.assertEquals(expectedRow2, results.get(2));
   }
 
   @Test
@@ -587,10 +587,10 @@ public class GroupByLimitPushDownInsufficientBufferTest extends InitializedNullH
         "metA", 190L
     );
 
-    Assert.assertEquals(3, results.size());
-    Assert.assertEquals(expectedRow0, results.get(0));
-    Assert.assertEquals(expectedRow1, results.get(1));
-    Assert.assertEquals(expectedRow2, results.get(2));
+    Assertions.assertEquals(3, results.size());
+    Assertions.assertEquals(expectedRow0, results.get(0));
+    Assertions.assertEquals(expectedRow1, results.get(1));
+    Assertions.assertEquals(expectedRow2, results.get(2));
   }
 
   private List<QueryRunner<ResultRow>> getRunner1()
diff --git a/processing/src/test/java/org/apache/druid/query/groupby/GroupByLimitPushDownMultiNodeMergeTest.java b/processing/src/test/java/org/apache/druid/query/groupby/GroupByLimitPushDownMultiNodeMergeTest.java
index df03020a8ac..5b084a57de4 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/GroupByLimitPushDownMultiNodeMergeTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/GroupByLimitPushDownMultiNodeMergeTest.java
@@ -85,10 +85,10 @@ import org.apache.druid.testing.InitializedNullHandlingTest;
 import org.apache.druid.timeline.SegmentId;
 import org.joda.time.DateTimeZone;
 import org.joda.time.Period;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+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 java.io.File;
 import java.util.ArrayList;
@@ -161,7 +161,7 @@ public class GroupByLimitPushDownMultiNodeMergeTest extends InitializedNullHandl
         .build();
   }
 
-  @Before
+  @BeforeEach
   public void setup() throws Exception
   {
     tmpDir = FileUtils.createTempDir();
@@ -538,10 +538,10 @@ public class GroupByLimitPushDownMultiNodeMergeTest extends InitializedNullHandl
 
     resourceCloser.register(() -> {
       // Verify that all objects have been returned to the pools.
-      Assert.assertEquals(0, bufferPool.getOutstandingObjectCount());
-      Assert.assertEquals(0, mergePoolBroker.getOutstandingObjectCount());
-      Assert.assertEquals(0, mergePoolHistorical.getOutstandingObjectCount());
-      Assert.assertEquals(0, mergePoolHistorical2.getOutstandingObjectCount());
+      Assertions.assertEquals(0, bufferPool.getOutstandingObjectCount());
+      Assertions.assertEquals(0, mergePoolBroker.getOutstandingObjectCount());
+      Assertions.assertEquals(0, mergePoolHistorical.getOutstandingObjectCount());
+      Assertions.assertEquals(0, mergePoolHistorical2.getOutstandingObjectCount());
     });
 
     final GroupByQueryConfig config = new GroupByQueryConfig()
@@ -634,7 +634,7 @@ public class GroupByLimitPushDownMultiNodeMergeTest extends InitializedNullHandl
     );
   }
 
-  @After
+  @AfterEach
   public void tearDown() throws Exception
   {
     for (IncrementalIndex incrementalIndex : incrementalIndices) {
@@ -789,11 +789,11 @@ public class GroupByLimitPushDownMultiNodeMergeTest extends InitializedNullHandl
         "a0", 2L
     );
     System.out.println(results);
-    Assert.assertEquals(4, results.size());
-    Assert.assertEquals(expectedRow0, results.get(0));
-    Assert.assertEquals(expectedRow1, results.get(1));
-    Assert.assertEquals(expectedRow2, results.get(2));
-    Assert.assertEquals(expectedRow3, results.get(3));
+    Assertions.assertEquals(4, results.size());
+    Assertions.assertEquals(expectedRow0, results.get(0));
+    Assertions.assertEquals(expectedRow1, results.get(1));
+    Assertions.assertEquals(expectedRow2, results.get(2));
+    Assertions.assertEquals(expectedRow3, results.get(3));
   }
 
   @Test
@@ -919,11 +919,11 @@ public class GroupByLimitPushDownMultiNodeMergeTest extends InitializedNullHandl
         "metASum", 7726L
     );
 
-    Assert.assertEquals(4, results.size());
-    Assert.assertEquals(expectedRow0, results.get(0));
-    Assert.assertEquals(expectedRow1, results.get(1));
-    Assert.assertEquals(expectedRow2, results.get(2));
-    Assert.assertEquals(expectedRow3, results.get(3));
+    Assertions.assertEquals(4, results.size());
+    Assertions.assertEquals(expectedRow0, results.get(0));
+    Assertions.assertEquals(expectedRow1, results.get(1));
+    Assertions.assertEquals(expectedRow2, results.get(2));
+    Assertions.assertEquals(expectedRow3, results.get(3));
   }
 
   @Test
@@ -945,8 +945,8 @@ public class GroupByLimitPushDownMultiNodeMergeTest extends InitializedNullHandl
         ResultRow.of("orange", "raw", 11)
     );
 
-    Assert.assertEquals(expectedResults.toString(), resultsWithoutLimitPushDown.toString());
-    Assert.assertEquals(expectedResults.toString(), resultsWithLimitPushDown.toString());
+    Assertions.assertEquals(expectedResults.toString(), resultsWithoutLimitPushDown.toString());
+    Assertions.assertEquals(expectedResults.toString(), resultsWithLimitPushDown.toString());
   }
 
   private List<ResultRow> testForcePushLimitDownAccuracyWhenSortHasNonGroupingFieldsHelper(Map<String, Object> context)
diff --git a/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryMergeBufferTest.java b/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryMergeBufferTest.java
index 775a8c602bb..4dc2efeded9 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryMergeBufferTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryMergeBufferTest.java
@@ -39,13 +39,12 @@ import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
 import org.apache.druid.query.dimension.DefaultDimensionSpec;
 import org.apache.druid.segment.TestHelper;
 import org.apache.druid.testing.InitializedNullHandlingTest;
-import org.junit.AfterClass;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
@@ -54,7 +53,9 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
-@RunWith(Parameterized.class)
+@ParameterizedClass
+
+@MethodSource("constructorFeeder")
 public class GroupByQueryMergeBufferTest extends InitializedNullHandlingTest
 {
   private static final long TIMEOUT = 5000;
@@ -163,14 +164,12 @@ public class GroupByQueryMergeBufferTest extends InitializedNullHandlingTest
 
   private final QueryRunner<ResultRow> runner;
 
-  @AfterClass
+  @AfterAll
   public static void teardownClass()
   {
     BUFFER_POOL.close();
     MERGE_BUFFER_POOL.close();
   }
-
-  @Parameters(name = "{0}")
   public static Collection<Object[]> constructorFeeder()
   {
     final List<Object[]> args = new ArrayList<>();
@@ -185,7 +184,7 @@ public class GroupByQueryMergeBufferTest extends InitializedNullHandlingTest
     this.runner = FACTORY.mergeRunners(Execs.directExecutor(), ImmutableList.of(runner));
   }
 
-  @Before
+  @BeforeEach
   public void setup()
   {
     MERGE_BUFFER_POOL.resetMinRemainBufferNum();
@@ -203,11 +202,11 @@ public class GroupByQueryMergeBufferTest extends InitializedNullHandlingTest
         .setContext(ImmutableMap.of(QueryContexts.TIMEOUT_KEY, TIMEOUT))
         .build();
 
-    Assert.assertEquals(0, GroupByQueryResources.countRequiredMergeBufferNumForToolchestMerge(query));
+    Assertions.assertEquals(0, GroupByQueryResources.countRequiredMergeBufferNumForToolchestMerge(query));
     GroupByQueryRunnerTestHelper.runQuery(FACTORY, runner, query);
 
-    Assert.assertEquals(3, MERGE_BUFFER_POOL.getMinRemainBufferNum());
-    Assert.assertEquals(4, MERGE_BUFFER_POOL.getPoolSize());
+    Assertions.assertEquals(3, MERGE_BUFFER_POOL.getMinRemainBufferNum());
+    Assertions.assertEquals(4, MERGE_BUFFER_POOL.getPoolSize());
   }
 
   @Test
@@ -232,11 +231,11 @@ public class GroupByQueryMergeBufferTest extends InitializedNullHandlingTest
         .setContext(ImmutableMap.of(QueryContexts.TIMEOUT_KEY, TIMEOUT))
         .build();
 
-    Assert.assertEquals(1, GroupByQueryResources.countRequiredMergeBufferNumForToolchestMerge(query));
+    Assertions.assertEquals(1, GroupByQueryResources.countRequiredMergeBufferNumForToolchestMerge(query));
     GroupByQueryRunnerTestHelper.runQuery(FACTORY, runner, query);
 
-    Assert.assertEquals(2, MERGE_BUFFER_POOL.getMinRemainBufferNum());
-    Assert.assertEquals(4, MERGE_BUFFER_POOL.getPoolSize());
+    Assertions.assertEquals(2, MERGE_BUFFER_POOL.getMinRemainBufferNum());
+    Assertions.assertEquals(4, MERGE_BUFFER_POOL.getPoolSize());
   }
 
   @Test
@@ -272,12 +271,12 @@ public class GroupByQueryMergeBufferTest extends InitializedNullHandlingTest
         .setContext(ImmutableMap.of(QueryContexts.TIMEOUT_KEY, TIMEOUT))
         .build();
 
-    Assert.assertEquals(2, GroupByQueryResources.countRequiredMergeBufferNumForToolchestMerge(query));
+    Assertions.assertEquals(2, GroupByQueryResources.countRequiredMergeBufferNumForToolchestMerge(query));
     GroupByQueryRunnerTestHelper.runQuery(FACTORY, runner, query);
 
     // This should be 1 because the broker needs 2 buffers and the queryable node needs one.
-    Assert.assertEquals(1, MERGE_BUFFER_POOL.getMinRemainBufferNum());
-    Assert.assertEquals(4, MERGE_BUFFER_POOL.getPoolSize());
+    Assertions.assertEquals(1, MERGE_BUFFER_POOL.getMinRemainBufferNum());
+    Assertions.assertEquals(4, MERGE_BUFFER_POOL.getPoolSize());
   }
 
   @Test
@@ -326,12 +325,12 @@ public class GroupByQueryMergeBufferTest extends InitializedNullHandlingTest
         .setContext(ImmutableMap.of(QueryContexts.TIMEOUT_KEY, TIMEOUT))
         .build();
 
-    Assert.assertEquals(2, GroupByQueryResources.countRequiredMergeBufferNumForToolchestMerge(query));
+    Assertions.assertEquals(2, GroupByQueryResources.countRequiredMergeBufferNumForToolchestMerge(query));
     GroupByQueryRunnerTestHelper.runQuery(FACTORY, runner, query);
 
     // This should be 1 because the broker needs 2 buffers and the queryable node needs one.
-    Assert.assertEquals(1, MERGE_BUFFER_POOL.getMinRemainBufferNum());
-    Assert.assertEquals(4, MERGE_BUFFER_POOL.getPoolSize());
+    Assertions.assertEquals(1, MERGE_BUFFER_POOL.getMinRemainBufferNum());
+    Assertions.assertEquals(4, MERGE_BUFFER_POOL.getPoolSize());
   }
 
   @Test
@@ -355,12 +354,12 @@ public class GroupByQueryMergeBufferTest extends InitializedNullHandlingTest
         .setContext(ImmutableMap.of(QueryContexts.TIMEOUT_KEY, TIMEOUT))
         .build();
 
-    Assert.assertEquals(1, GroupByQueryResources.countRequiredMergeBufferNumForToolchestMerge(query));
+    Assertions.assertEquals(1, GroupByQueryResources.countRequiredMergeBufferNumForToolchestMerge(query));
     GroupByQueryRunnerTestHelper.runQuery(FACTORY, runner, query);
 
     // 1 for subtotal and 1 for GroupByQueryRunnerFactory#mergeRunners
-    Assert.assertEquals(2, MERGE_BUFFER_POOL.getMinRemainBufferNum());
-    Assert.assertEquals(4, MERGE_BUFFER_POOL.getPoolSize());
+    Assertions.assertEquals(2, MERGE_BUFFER_POOL.getMinRemainBufferNum());
+    Assertions.assertEquals(4, MERGE_BUFFER_POOL.getPoolSize());
   }
 
   @Test
@@ -384,12 +383,12 @@ public class GroupByQueryMergeBufferTest extends InitializedNullHandlingTest
         .setContext(ImmutableMap.of(QueryContexts.TIMEOUT_KEY, TIMEOUT))
         .build();
 
-    Assert.assertEquals(2, GroupByQueryResources.countRequiredMergeBufferNumForToolchestMerge(query));
+    Assertions.assertEquals(2, GroupByQueryResources.countRequiredMergeBufferNumForToolchestMerge(query));
     GroupByQueryRunnerTestHelper.runQuery(FACTORY, runner, query);
 
     // 2 needed by subtotal and 1 for GroupByQueryRunnerFactory#mergeRunners
-    Assert.assertEquals(1, MERGE_BUFFER_POOL.getMinRemainBufferNum());
-    Assert.assertEquals(4, MERGE_BUFFER_POOL.getPoolSize());
+    Assertions.assertEquals(1, MERGE_BUFFER_POOL.getMinRemainBufferNum());
+    Assertions.assertEquals(4, MERGE_BUFFER_POOL.getPoolSize());
   }
 
   @Test
@@ -426,12 +425,12 @@ public class GroupByQueryMergeBufferTest extends InitializedNullHandlingTest
         .setContext(ImmutableMap.of(QueryContexts.TIMEOUT_KEY, TIMEOUT))
         .build();
 
-    Assert.assertEquals(3, GroupByQueryResources.countRequiredMergeBufferNumForToolchestMerge(query));
+    Assertions.assertEquals(3, GroupByQueryResources.countRequiredMergeBufferNumForToolchestMerge(query));
     GroupByQueryRunnerTestHelper.runQuery(FACTORY, runner, query);
 
     // 2 for subtotal, 1 for nested group by and 1 for GroupByQueryRunnerFactory#mergeRunners
-    Assert.assertEquals(0, MERGE_BUFFER_POOL.getMinRemainBufferNum());
-    Assert.assertEquals(4, MERGE_BUFFER_POOL.getPoolSize());
+    Assertions.assertEquals(0, MERGE_BUFFER_POOL.getMinRemainBufferNum());
+    Assertions.assertEquals(4, MERGE_BUFFER_POOL.getPoolSize());
   }
 
   @Test
@@ -472,11 +471,11 @@ public class GroupByQueryMergeBufferTest extends InitializedNullHandlingTest
         .setContext(ImmutableMap.of(QueryContexts.TIMEOUT_KEY, TIMEOUT))
         .build();
 
-    Assert.assertEquals(3, GroupByQueryResources.countRequiredMergeBufferNumForToolchestMerge(query));
+    Assertions.assertEquals(3, GroupByQueryResources.countRequiredMergeBufferNumForToolchestMerge(query));
     GroupByQueryRunnerTestHelper.runQuery(FACTORY, runner, query);
 
     // 2 for subtotal, 1 for nested group by and 1 for GroupByQueryRunnerFactory#mergeRunners
-    Assert.assertEquals(0, MERGE_BUFFER_POOL.getMinRemainBufferNum());
-    Assert.assertEquals(4, MERGE_BUFFER_POOL.getPoolSize());
+    Assertions.assertEquals(0, MERGE_BUFFER_POOL.getMinRemainBufferNum());
+    Assertions.assertEquals(4, MERGE_BUFFER_POOL.getPoolSize());
   }
 }
diff --git a/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryQueryToolChestTest.java b/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryQueryToolChestTest.java
index 80731a244c9..1fc79f37674 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryQueryToolChestTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryQueryToolChestTest.java
@@ -79,9 +79,9 @@ import org.apache.druid.segment.column.RowSignature;
 import org.apache.druid.segment.column.ValueType;
 import org.apache.druid.segment.virtual.ExpressionVirtualColumn;
 import org.apache.druid.testing.InitializedNullHandlingTest;
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
 import java.nio.ByteBuffer;
@@ -91,7 +91,7 @@ import java.util.List;
 
 public class GroupByQueryQueryToolChestTest extends InitializedNullHandlingTest
 {
-  @BeforeClass
+  @BeforeAll
   public static void setUpClass()
   {
     AggregatorsModule.registerComplexMetricsAndSerde();
@@ -136,8 +136,8 @@ public class GroupByQueryQueryToolChestTest extends InitializedNullHandlingTest
     final CacheStrategy<ResultRow, Object, GroupByQuery> strategy2 =
         new GroupByQueryQueryToolChest(null, null).getCacheStrategy(query2, mapper);
 
-    Assert.assertTrue(Arrays.equals(strategy1.computeCacheKey(query1), strategy2.computeCacheKey(query2)));
-    Assert.assertFalse(Arrays.equals(
+    Assertions.assertTrue(Arrays.equals(strategy1.computeCacheKey(query1), strategy2.computeCacheKey(query2)));
+    Assertions.assertFalse(Arrays.equals(
         strategy1.computeResultLevelCacheKey(query1),
         strategy2.computeResultLevelCacheKey(query2)
     ));
@@ -197,8 +197,8 @@ public class GroupByQueryQueryToolChestTest extends InitializedNullHandlingTest
     final CacheStrategy<ResultRow, Object, GroupByQuery> strategy2 =
         new GroupByQueryQueryToolChest(null, null).getCacheStrategy(query2, mapper);
 
-    Assert.assertTrue(Arrays.equals(strategy1.computeCacheKey(query1), strategy2.computeCacheKey(query2)));
-    Assert.assertFalse(Arrays.equals(
+    Assertions.assertTrue(Arrays.equals(strategy1.computeCacheKey(query1), strategy2.computeCacheKey(query2)));
+    Assertions.assertFalse(Arrays.equals(
         strategy1.computeResultLevelCacheKey(query1),
         strategy2.computeResultLevelCacheKey(query2)
     ));
@@ -260,8 +260,8 @@ public class GroupByQueryQueryToolChestTest extends InitializedNullHandlingTest
     final CacheStrategy<ResultRow, Object, GroupByQuery> strategy2 =
         new GroupByQueryQueryToolChest(null, null).getCacheStrategy(query2, mapper);
 
-    Assert.assertTrue(Arrays.equals(strategy1.computeCacheKey(query1), strategy2.computeCacheKey(query2)));
-    Assert.assertFalse(Arrays.equals(
+    Assertions.assertTrue(Arrays.equals(strategy1.computeCacheKey(query1), strategy2.computeCacheKey(query2)));
+    Assertions.assertFalse(Arrays.equals(
         strategy1.computeResultLevelCacheKey(query1),
         strategy2.computeResultLevelCacheKey(query2)
     ));
@@ -345,8 +345,8 @@ public class GroupByQueryQueryToolChestTest extends InitializedNullHandlingTest
     final CacheStrategy<ResultRow, Object, GroupByQuery> strategy2 =
         new GroupByQueryQueryToolChest(null, null).getCacheStrategy(query2, mapper);
 
-    Assert.assertTrue(Arrays.equals(strategy1.computeCacheKey(query1), strategy2.computeCacheKey(query2)));
-    Assert.assertFalse(Arrays.equals(
+    Assertions.assertTrue(Arrays.equals(strategy1.computeCacheKey(query1), strategy2.computeCacheKey(query2)));
+    Assertions.assertFalse(Arrays.equals(
         strategy1.computeResultLevelCacheKey(query1),
         strategy2.computeResultLevelCacheKey(query2)
     ));
@@ -437,8 +437,8 @@ public class GroupByQueryQueryToolChestTest extends InitializedNullHandlingTest
     final CacheStrategy<ResultRow, Object, GroupByQuery> strategy2 =
         new GroupByQueryQueryToolChest(null, null).getCacheStrategy(query2, mapper);
 
-    Assert.assertTrue(Arrays.equals(strategy1.computeCacheKey(query1), strategy2.computeCacheKey(query2)));
-    Assert.assertFalse(Arrays.equals(
+    Assertions.assertTrue(Arrays.equals(strategy1.computeCacheKey(query1), strategy2.computeCacheKey(query2)));
+    Assertions.assertFalse(Arrays.equals(
         strategy1.computeResultLevelCacheKey(query1),
         strategy2.computeResultLevelCacheKey(query2)
     ));
@@ -501,8 +501,8 @@ public class GroupByQueryQueryToolChestTest extends InitializedNullHandlingTest
     final CacheStrategy<ResultRow, Object, GroupByQuery> strategy2 =
         new GroupByQueryQueryToolChest(null, null).getCacheStrategy(query2, mapper);
 
-    Assert.assertTrue(Arrays.equals(strategy1.computeCacheKey(query1), strategy2.computeCacheKey(query2)));
-    Assert.assertFalse(Arrays.equals(
+    Assertions.assertTrue(Arrays.equals(strategy1.computeCacheKey(query1), strategy2.computeCacheKey(query2)));
+    Assertions.assertFalse(Arrays.equals(
         strategy1.computeResultLevelCacheKey(query1),
         strategy2.computeResultLevelCacheKey(query2)
     ));
@@ -556,7 +556,7 @@ public class GroupByQueryQueryToolChestTest extends InitializedNullHandlingTest
 
     ResultRow fromCacheResult = strategy.pullFromSegmentLevelCache().apply(fromCacheValue);
 
-    Assert.assertEquals(result1, fromCacheResult);
+    Assertions.assertEquals(result1, fromCacheResult);
   }
 
   @Test
@@ -608,7 +608,7 @@ public class GroupByQueryQueryToolChestTest extends InitializedNullHandlingTest
 
     ResultRow fromCacheResult = strategy.pullFromSegmentLevelCache().apply(fromCacheValue);
 
-    Assert.assertEquals(result1, fromCacheResult);
+    Assertions.assertEquals(result1, fromCacheResult);
   }
 
   @Test
@@ -639,58 +639,58 @@ public class GroupByQueryQueryToolChestTest extends InitializedNullHandlingTest
     final Object[] rowObjects = {DateTimes.of("2000").getMillis(), "foo", 100, 10.0};
     final ResultRow resultRow = ResultRow.of(rowObjects);
 
-    Assert.assertArrayEquals(
-        "standard mapper reads ResultRows",
+    Assertions.assertArrayEquals(
         rowObjects,
         objectMapper.readValue(
             arraysObjectMapper.writeValueAsBytes(resultRow),
             Object[].class
-        )
+        ),
+        "standard mapper reads ResultRows"
     );
 
-    Assert.assertEquals(
-        "standard mapper reads MapBasedRows",
+    Assertions.assertEquals(
         resultRow.toMapBasedRow(query),
         objectMapper.readValue(
             mapsObjectMapper.writeValueAsBytes(resultRow),
             Row.class
-        )
+        ),
+        "standard mapper reads MapBasedRows"
     );
 
-    Assert.assertEquals(
-        "array mapper reads arrays",
+    Assertions.assertEquals(
         resultRow,
         arraysObjectMapper.readValue(
             arraysObjectMapper.writeValueAsBytes(resultRow),
             ResultRow.class
-        )
+        ),
+        "array mapper reads arrays"
     );
 
-    Assert.assertEquals(
-        "array mapper reads arrays (2)",
+    Assertions.assertEquals(
         resultRow,
         arraysObjectMapper.readValue(
             StringUtils.format("[%s, \"foo\", 100, 10.0]", DateTimes.of("2000").getMillis()),
             ResultRow.class
-        )
+        ),
+        "array mapper reads arrays (2)"
     );
 
-    Assert.assertEquals(
-        "map mapper reads arrays",
+    Assertions.assertEquals(
         resultRow,
         mapsObjectMapper.readValue(
             arraysObjectMapper.writeValueAsBytes(resultRow),
             ResultRow.class
-        )
+        ),
+        "map mapper reads arrays"
     );
 
-    Assert.assertEquals(
-        "map mapper reads maps",
+    Assertions.assertEquals(
         resultRow,
         mapsObjectMapper.readValue(
             mapsObjectMapper.writeValueAsBytes(resultRow),
             ResultRow.class
-        )
+        ),
+        "map mapper reads maps"
     );
   }
 
@@ -738,40 +738,40 @@ public class GroupByQueryQueryToolChestTest extends InitializedNullHandlingTest
     // There are no tests with the standard mapper since it cannot convert the generic deserialized type for Pair class
     // into the Pair class
 
-    Assert.assertEquals(
-        "array mapper reads arrays",
+    Assertions.assertEquals(
         resultRow,
         arraysObjectMapper.readValue(
             arraysObjectMapper.writeValueAsBytes(resultRow),
             ResultRow.class
-        )
+        ),
+        "array mapper reads arrays"
     );
 
-    Assert.assertEquals(
-        "array mapper reads arrays (2)",
+    Assertions.assertEquals(
         resultRow,
         arraysObjectMapper.readValue(
             StringUtils.format("[%s, \"foo\", {\"lhs\":1,\"rhs\":\"test\"}, 100, 10.0]", DateTimes.of("2000").getMillis()),
             ResultRow.class
-        )
+        ),
+        "array mapper reads arrays (2)"
     );
 
-    Assert.assertEquals(
-        "map mapper reads arrays",
+    Assertions.assertEquals(
         resultRow,
         mapsObjectMapper.readValue(
             arraysObjectMapper.writeValueAsBytes(resultRow),
             ResultRow.class
-        )
+        ),
+        "map mapper reads arrays"
     );
 
-    Assert.assertEquals(
-        "map mapper reads maps",
+    Assertions.assertEquals(
         resultRow,
         mapsObjectMapper.readValue(
             mapsObjectMapper.writeValueAsBytes(resultRow),
             ResultRow.class
-        )
+        ),
+        "map mapper reads maps"
     );
   }
 
@@ -817,7 +817,7 @@ public class GroupByQueryQueryToolChestTest extends InitializedNullHandlingTest
     final ResultRow resultRow = ResultRow.of(rowObjects);
 
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         resultRow,
         arraysObjectMapper.readValue(
             StringUtils.format("[%s, \"foo\", 100, 10.0]", DateTimes.of("2000").getMillis()),
@@ -825,40 +825,40 @@ public class GroupByQueryQueryToolChestTest extends InitializedNullHandlingTest
         )
     );
 
-    Assert.assertArrayEquals(
-        "standard mapper reads ResultRows",
+    Assertions.assertArrayEquals(
         rowObjects,
         objectMapper.readValue(
             arraysObjectMapper.writeValueAsBytes(resultRow),
             Object[].class
-        )
+        ),
+        "standard mapper reads ResultRows"
     );
 
-    Assert.assertEquals(
-        "standard mapper reads MapBasedRows",
+    Assertions.assertEquals(
         resultRow.toMapBasedRow(query),
         objectMapper.readValue(
             mapsObjectMapper.writeValueAsBytes(resultRow),
             Row.class
-        )
+        ),
+        "standard mapper reads MapBasedRows"
     );
 
-    Assert.assertEquals(
-        "array mapper reads arrays",
+    Assertions.assertEquals(
         resultRow,
         arraysObjectMapper.readValue(
             arraysObjectMapper.writeValueAsBytes(resultRow),
             ResultRow.class
-        )
+        ),
+        "array mapper reads arrays"
     );
 
-    Assert.assertEquals(
-        "array mapper reads maps",
+    Assertions.assertEquals(
         resultRow,
         arraysObjectMapper.readValue(
             mapsObjectMapper.writeValueAsBytes(resultRow),
             ResultRow.class
-        )
+        ),
+        "array mapper reads maps"
     );
 
     TestHelper.assertRow(
@@ -877,22 +877,22 @@ public class GroupByQueryQueryToolChestTest extends InitializedNullHandlingTest
         )
     );
 
-    Assert.assertEquals(
-        "map mapper reads arrays",
+    Assertions.assertEquals(
         resultRow,
         mapsObjectMapper.readValue(
             arraysObjectMapper.writeValueAsBytes(resultRow),
             ResultRow.class
-        )
+        ),
+        "map mapper reads arrays"
     );
 
-    Assert.assertEquals(
-        "map mapper reads maps",
+    Assertions.assertEquals(
         resultRow,
         mapsObjectMapper.readValue(
             mapsObjectMapper.writeValueAsBytes(resultRow),
             ResultRow.class
-        )
+        ),
+        "map mapper reads maps"
     );
   }
 
@@ -908,7 +908,7 @@ public class GroupByQueryQueryToolChestTest extends InitializedNullHandlingTest
         .setPostAggregatorSpecs(ImmutableList.of(QueryRunnerTestHelper.CONSTANT))
         .build();
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         RowSignature.builder()
                     .add("dim", ColumnType.STRING)
                     .add("rows", ColumnType.LONG)
@@ -932,7 +932,7 @@ public class GroupByQueryQueryToolChestTest extends InitializedNullHandlingTest
         .setPostAggregatorSpecs(ImmutableList.of(QueryRunnerTestHelper.CONSTANT))
         .build();
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         RowSignature.builder()
                     .addTimeColumn()
                     .add("dim", ColumnType.STRING)
@@ -1006,7 +1006,7 @@ public class GroupByQueryQueryToolChestTest extends InitializedNullHandlingTest
   @Test
   public void testCanPerformSubqueryOnGroupBys()
   {
-    Assert.assertTrue(
+    Assertions.assertTrue(
         new GroupByQueryQueryToolChest(null, null).canPerformSubquery(
             new GroupByQuery.Builder()
                 .setDataSource(
@@ -1028,7 +1028,7 @@ public class GroupByQueryQueryToolChestTest extends InitializedNullHandlingTest
   @Test
   public void testCanPerformSubqueryOnTimeseries()
   {
-    Assert.assertFalse(
+    Assertions.assertFalse(
         new GroupByQueryQueryToolChest(null, null).canPerformSubquery(
             Druids.newTimeseriesQueryBuilder()
                   .dataSource(QueryRunnerTestHelper.DATA_SOURCE)
@@ -1042,7 +1042,7 @@ public class GroupByQueryQueryToolChestTest extends InitializedNullHandlingTest
   @Test
   public void testCanPerformSubqueryOnGroupByOfTimeseries()
   {
-    Assert.assertFalse(
+    Assertions.assertFalse(
         new GroupByQueryQueryToolChest(null, null).canPerformSubquery(
             new GroupByQuery.Builder()
                 .setDataSource(
@@ -1137,7 +1137,7 @@ public class GroupByQueryQueryToolChestTest extends InitializedNullHandlingTest
 
     ResultRow fromCacheResult = strategy.pullFromSegmentLevelCache().apply(fromCacheValue);
 
-    Assert.assertEquals(result1, fromCacheResult);
+    Assertions.assertEquals(result1, fromCacheResult);
 
     // test timestamps that result in integer size millis
     final ResultRow result2 = ResultRow.of(123L, dimValue, 1, dimValue, 10, 20);
@@ -1163,7 +1163,7 @@ public class GroupByQueryQueryToolChestTest extends InitializedNullHandlingTest
     );
 
     ResultRow fromResultCacheResult = strategy.pullFromCache(true).apply(fromResultCacheValue);
-    Assert.assertEquals(typeAdjustedResult2, fromResultCacheResult);
+    Assertions.assertEquals(typeAdjustedResult2, fromResultCacheResult);
   }
 
   @Test
@@ -1216,8 +1216,8 @@ public class GroupByQueryQueryToolChestTest extends InitializedNullHandlingTest
     final CacheStrategy<ResultRow, Object, GroupByQuery> strategy2 =
         new GroupByQueryQueryToolChest(null, null).getCacheStrategy(query2, mapper);
 
-    Assert.assertFalse(Arrays.equals(strategy1.computeCacheKey(query1), strategy2.computeCacheKey(query2)));
-    Assert.assertFalse(Arrays.equals(
+    Assertions.assertFalse(Arrays.equals(strategy1.computeCacheKey(query1), strategy2.computeCacheKey(query2)));
+    Assertions.assertFalse(Arrays.equals(
         strategy1.computeCacheKey(query1),
         strategy2.computeCacheKey(queryNoLimit)
     ));
@@ -1253,8 +1253,8 @@ public class GroupByQueryQueryToolChestTest extends InitializedNullHandlingTest
     final CacheStrategy<ResultRow, Object, GroupByQuery> strategy2 =
         new GroupByQueryQueryToolChest(null, null).getCacheStrategy(query2, mapper);
 
-    Assert.assertFalse(Arrays.equals(strategy1.computeCacheKey(query1), strategy2.computeCacheKey(query2)));
-    Assert.assertTrue(
+    Assertions.assertFalse(Arrays.equals(strategy1.computeCacheKey(query1), strategy2.computeCacheKey(query2)));
+    Assertions.assertTrue(
         Arrays.equals(
             strategy1.computeResultLevelCacheKey(query1),
             strategy2.computeResultLevelCacheKey(query2)
@@ -1309,17 +1309,17 @@ public class GroupByQueryQueryToolChestTest extends InitializedNullHandlingTest
     final GroupByQueryQueryToolChest queryToolChest = new GroupByQueryQueryToolChest(groupingEngine, groupByResourcesReservationPool);
     final ObjectMapper mapper = TestHelper.makeJsonMapper();
     CacheStrategy<ResultRow, Object, GroupByQuery> cacheStrategy = queryToolChest.getCacheStrategy(query, mapper);
-    Assert.assertTrue(
-        "result level cache on broker server for GroupByStrategyV2 should be enabled",
-        cacheStrategy.isCacheable(query, false, false)
+    Assertions.assertTrue(
+        cacheStrategy.isCacheable(query, false, false),
+        "result level cache on broker server for GroupByStrategyV2 should be enabled"
     );
-    Assert.assertFalse(
-        "segment level cache on broker server for GroupByStrategyV2 should be disabled",
-        cacheStrategy.isCacheable(query, false, true)
+    Assertions.assertFalse(
+        cacheStrategy.isCacheable(query, false, true),
+        "segment level cache on broker server for GroupByStrategyV2 should be disabled"
     );
-    Assert.assertTrue(
-        "segment level cache on data server for GroupByStrategyV2 should be enabled",
-        cacheStrategy.isCacheable(query, true, true)
+    Assertions.assertTrue(
+        cacheStrategy.isCacheable(query, true, true),
+        "segment level cache on data server for GroupByStrategyV2 should be enabled"
     );
   }
 }
diff --git a/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerFailureTest.java b/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerFailureTest.java
index 2e52da567b6..9184038c42c 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerFailureTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerFailureTest.java
@@ -43,16 +43,13 @@ import org.apache.druid.query.ResourceLimitExceededException;
 import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
 import org.apache.druid.query.dimension.DefaultDimensionSpec;
 import org.apache.druid.segment.TestHelper;
-import org.junit.After;
-import org.junit.AfterClass;
-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.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.api.AfterAll;
+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.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
@@ -64,7 +61,9 @@ import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
 
-@RunWith(Parameterized.class)
+@ParameterizedClass
+
+@MethodSource("constructorFeeder")
 public class GroupByQueryRunnerFailureTest
 {
   private QueryProcessingPool processingPool;
@@ -96,9 +95,6 @@ public class GroupByQueryRunnerFailureTest
     }
   };
 
-  @Rule
-  public ExpectedException expectedException = ExpectedException.none();
-
   private static GroupByQueryRunnerFactory makeQueryRunnerFactory(
       final ObjectMapper mapper,
       final GroupByQueryConfig config
@@ -140,13 +136,13 @@ public class GroupByQueryRunnerFailureTest
 
   private QueryRunner<ResultRow> runner;
 
-  @Before
+  @BeforeEach
   public void setUp()
   {
-    Assert.assertEquals(
-        "MERGE_BUFFER_POOL size, pre-test",
+    Assertions.assertEquals(
         MERGE_BUFFER_POOL.maxSize(),
-        MERGE_BUFFER_POOL.getPoolSize()
+        MERGE_BUFFER_POOL.getPoolSize(),
+        "MERGE_BUFFER_POOL size, pre-test"
     );
     processingPool = new ForwardingQueryProcessingPool(
         Execs.multiThreaded(2, "GroupByQueryRunnerFailureTestExecutor-%d"),
@@ -154,25 +150,23 @@ public class GroupByQueryRunnerFailureTest
     );
   }
 
-  @After
+  @AfterEach
   public void tearDown()
   {
-    Assert.assertEquals(
-        "MERGE_BUFFER_POOL size, post-test",
+    Assertions.assertEquals(
         MERGE_BUFFER_POOL.maxSize(),
-        MERGE_BUFFER_POOL.getPoolSize()
+        MERGE_BUFFER_POOL.getPoolSize(),
+        "MERGE_BUFFER_POOL size, post-test"
     );
     processingPool.shutdown();
   }
 
-  @AfterClass
+  @AfterAll
   public static void teardownClass()
   {
     BUFFER_POOL.close();
     MERGE_BUFFER_POOL.close();
   }
-
-  @Parameters(name = "{0}")
   public static Collection<Object[]> constructorFeeder()
   {
     final List<Object[]> args = new ArrayList<>();
@@ -187,12 +181,10 @@ public class GroupByQueryRunnerFailureTest
     this.runner = FACTORY.mergeRunners(Execs.directExecutor(), ImmutableList.of(runner));
   }
 
-  @Test(timeout = 60_000L)
+  @Test
+  @org.junit.jupiter.api.Timeout(value = 60_000L, unit = java.util.concurrent.TimeUnit.MILLISECONDS)
   public void testNotEnoughMergeBuffersOnQueryable()
   {
-    expectedException.expect(ResourceLimitExceededException.class);
-    expectedException.expectMessage("Query needs 2 merge buffers, but only 1 merge buffers were configured");
-
     final GroupByQuery query = GroupByQuery
         .builder()
         .setDataSource(
@@ -212,14 +204,19 @@ public class GroupByQueryRunnerFailureTest
         .setContext(ImmutableMap.of(QueryContexts.TIMEOUT_KEY, 500))
         .build();
 
-    GroupByQueryRunnerTestHelper.runQuery(FACTORY, runner, query);
+    final ResourceLimitExceededException exception = Assertions.assertThrows(
+        ResourceLimitExceededException.class,
+        () -> GroupByQueryRunnerTestHelper.runQuery(FACTORY, runner, query)
+    );
+    Assertions.assertTrue(
+        exception.getMessage().contains("Query needs 2 merge buffers, but only 1 merge buffers were configured")
+    );
   }
 
-  @Test(timeout = 60_000L)
+  @Test
+  @org.junit.jupiter.api.Timeout(value = 60_000L, unit = java.util.concurrent.TimeUnit.MILLISECONDS)
   public void testResourceLimitExceededOnBroker()
   {
-    expectedException.expect(ResourceLimitExceededException.class);
-
     final GroupByQuery query = GroupByQuery
         .builder()
         .setDataSource(
@@ -250,10 +247,14 @@ public class GroupByQueryRunnerFailureTest
         .setContext(ImmutableMap.of(QueryContexts.TIMEOUT_KEY, 500))
         .build();
 
-    GroupByQueryRunnerTestHelper.runQuery(FACTORY, runner, query);
+    Assertions.assertThrows(
+        ResourceLimitExceededException.class,
+        () -> GroupByQueryRunnerTestHelper.runQuery(FACTORY, runner, query)
+    );
   }
 
-  @Test(timeout = 60_000L)
+  @Test
+  @org.junit.jupiter.api.Timeout(value = 60_000L, unit = java.util.concurrent.TimeUnit.MILLISECONDS)
   public void testInsufficientResourcesOnBroker()
   {
     final GroupByQuery query = GroupByQuery
@@ -278,9 +279,13 @@ public class GroupByQueryRunnerFailureTest
     List<ReferenceCountingResourceHolder<ByteBuffer>> holder = null;
     try {
       holder = MERGE_BUFFER_POOL.takeBatch(1, 10);
-      expectedException.expect(ResourceLimitExceededException.class);
-      expectedException.expectMessage("Query needs 2 merge buffers, but only 1 merge buffers were configured");
-      GroupByQueryRunnerTestHelper.runQuery(FACTORY, runner, query);
+      final ResourceLimitExceededException exception = Assertions.assertThrows(
+          ResourceLimitExceededException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(FACTORY, runner, query)
+      );
+      Assertions.assertTrue(
+          exception.getMessage().contains("Query needs 2 merge buffers, but only 1 merge buffers were configured")
+      );
     }
     finally {
       if (holder != null) {
@@ -289,7 +294,8 @@ public class GroupByQueryRunnerFailureTest
     }
   }
 
-  @Test(timeout = 60_000L)
+  @Test
+  @org.junit.jupiter.api.Timeout(value = 60_000L, unit = java.util.concurrent.TimeUnit.MILLISECONDS)
   public void testTimeoutExceptionOnQueryable_singleThreaded()
   {
     final GroupByQuery query = GroupByQuery
@@ -327,15 +333,16 @@ public class GroupByQueryRunnerFailureTest
 
     QueryRunner<ResultRow> mergeRunners = factory.mergeRunners(Execs.directExecutor(), ImmutableList.of(runner, mockRunner));
 
-    QueryTimeoutException ex = Assert.assertThrows(
+    QueryTimeoutException ex = Assertions.assertThrows(
         QueryTimeoutException.class,
         () -> GroupByQueryRunnerTestHelper.runQuery(factory, mergeRunners, query)
     );
     // Assert overall timeout is triggered
-    Assert.assertEquals("Query [test] timed out", ex.getMessage());
+    Assertions.assertEquals("Query [test] timed out", ex.getMessage());
   }
 
-  @Test(timeout = 60_000L)
+  @Test
+  @org.junit.jupiter.api.Timeout(value = 60_000L, unit = java.util.concurrent.TimeUnit.MILLISECONDS)
   public void testTimeoutExceptionOnQueryable_multiThreaded()
   {
     final GroupByQuery query = GroupByQuery
@@ -376,15 +383,16 @@ public class GroupByQueryRunnerFailureTest
         List.of(runner, mockRunner)
     );
 
-    QueryTimeoutException ex = Assert.assertThrows(
+    QueryTimeoutException ex = Assertions.assertThrows(
         QueryTimeoutException.class,
         () -> GroupByQueryRunnerTestHelper.runQuery(factory, mergeRunners, query)
     );
     // Assert overall timeout is triggered
-    Assert.assertEquals("Query [test] timed out", ex.getMessage());
+    Assertions.assertEquals("Query [test] timed out", ex.getMessage());
   }
 
-  @Test(timeout = 20_000L)
+  @Test
+  @org.junit.jupiter.api.Timeout(value = 20_000L, unit = java.util.concurrent.TimeUnit.MILLISECONDS)
   public void test_multiThreaded_perSegmentTimeout_causes_queryTimeout()
   {
     final GroupByQuery query = GroupByQuery
@@ -430,15 +438,16 @@ public class GroupByQueryRunnerFailureTest
         List.of(runner, mockRunner)
     );
 
-    QueryTimeoutException ex = Assert.assertThrows(
+    QueryTimeoutException ex = Assertions.assertThrows(
         QueryTimeoutException.class,
         () -> GroupByQueryRunnerTestHelper.runQuery(factory, mergeRunners, query)
     );
     // Assert per-segment timeout is triggered
-    Assert.assertEquals("Query timeout, cancelling pending results for query [test]. Per-segment timeout exceeded.", ex.getMessage());
+    Assertions.assertEquals("Query timeout, cancelling pending results for query [test]. Per-segment timeout exceeded.", ex.getMessage());
   }
 
-  @Test(timeout = 20_000L)
+  @Test
+  @org.junit.jupiter.api.Timeout(value = 20_000L, unit = java.util.concurrent.TimeUnit.MILLISECONDS)
   public void test_singleThreaded_perSegmentTimeout_causes_queryTimeout()
   {
     final GroupByQuery query = GroupByQuery
@@ -484,15 +493,16 @@ public class GroupByQueryRunnerFailureTest
         List.of(runner, mockRunner)
     );
 
-    QueryTimeoutException ex = Assert.assertThrows(
+    QueryTimeoutException ex = Assertions.assertThrows(
         QueryTimeoutException.class,
         () -> GroupByQueryRunnerTestHelper.runQuery(factory, mergeRunners, query)
     );
     // Assert per-segment timeout is triggered
-    Assert.assertEquals("Query timeout, cancelling pending results for query [test]. Per-segment timeout exceeded.", ex.getMessage());
+    Assertions.assertEquals("Query timeout, cancelling pending results for query [test]. Per-segment timeout exceeded.", ex.getMessage());
   }
 
-  @Test(timeout = 5_000L)
+  @Test
+  @org.junit.jupiter.api.Timeout(value = 5_000L, unit = java.util.concurrent.TimeUnit.MILLISECONDS)
   public void test_perSegmentTimeout_crossQuery() throws Exception
   {
     GroupByQueryRunnerFactory factory = makeQueryRunnerFactory(
@@ -568,7 +578,7 @@ public class GroupByQueryRunnerFailureTest
         thrown.set(e);
         return;
       }
-      Assert.fail("Expected QueryTimeoutException for slow query");
+      Assertions.fail("Expected QueryTimeoutException for slow query");
     });
 
     slowQueryThread.start();
@@ -585,20 +595,20 @@ public class GroupByQueryRunnerFailureTest
         );
       }
       catch (Exception e) {
-        Assert.fail("Expected fast query to succeed");
+        Assertions.fail("Expected fast query to succeed");
       }
     });
 
     fastQueryThread.start();
     boolean fastStartedEarly = fastStart.await(500, TimeUnit.MILLISECONDS);
-    Assert.assertFalse(
-        "Fast query should be blocked and not started while slow queries are running",
-        fastStartedEarly
+    Assertions.assertFalse(
+        fastStartedEarly,
+        "Fast query should be blocked and not started while slow queries are running"
     );
 
     fastQueryThread.join();
     slowQueryThread.join();
 
-    Assert.assertEquals("Query timeout, cancelling pending results for query [slow]. Per-segment timeout exceeded.", thrown.get().getMessage());
+    Assertions.assertEquals("Query timeout, cancelling pending results for query [slow]. Per-segment timeout exceeded.", thrown.get().getMessage());
   }
 }
diff --git a/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerTest.java b/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerTest.java
index cd1102a0330..75be85ce8b3 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/GroupByQueryRunnerTest.java
@@ -139,26 +139,19 @@ import org.apache.druid.segment.column.ColumnHolder;
 import org.apache.druid.segment.column.ColumnType;
 import org.apache.druid.segment.virtual.ExpressionVirtualColumn;
 import org.apache.druid.testing.InitializedNullHandlingTest;
-import org.hamcrest.BaseMatcher;
-import org.hamcrest.CoreMatchers;
-import org.hamcrest.Description;
 import org.joda.time.DateTime;
 import org.joda.time.DateTimeZone;
 import org.joda.time.Period;
-import org.junit.After;
-import org.junit.AfterClass;
-import org.junit.Assert;
-import org.junit.Assume;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Ignore;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.internal.matchers.ThrowableCauseMatcher;
-import org.junit.rules.ExpectedException;
-import org.junit.rules.ExternalResource;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Assumptions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -173,7 +166,9 @@ import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
-@RunWith(Parameterized.class)
+@ParameterizedClass
+
+@MethodSource("constructorFeeder")
 public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
 {
   public static final ObjectMapper DEFAULT_MAPPER = TestHelper.makeSmileMapper();
@@ -216,9 +211,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   private final GroupByStatsProvider statsProvider;
   private final boolean useVectorApi;
 
-  @Rule
-  public ExpectedException expectedException = ExpectedException.none();
-
   static final GroupByQueryConfig V2_CONFIG = new GroupByQueryConfig()
   {
     @Override
@@ -415,18 +407,12 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     return new GroupByQueryRunnerFactory(groupingEngine, toolChest, bufferPools.getProcessingPool());
   }
 
-  @Rule
-  public ExternalResource externalResource = new ExternalResource()
+  @BeforeEach
+  public void resetStats()
   {
-    @Override
-    protected void before()
-    {
-      // reset the aggregate before each test parameter is run
-      statsProvider.getStatsSince();
-    }
-  };
-
-  @Parameterized.Parameters(name = "{0}")
+    // reset the aggregate before each test parameter is run
+    statsProvider.getStatsSince();
+  }
   public static Collection<Object[]> constructorFeeder()
   {
     setUpClass();
@@ -459,7 +445,7 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     return constructors;
   }
 
-  @BeforeClass
+  @BeforeAll
   public static void setUpClass()
   {
     if (BUFFER_POOLS == null) {
@@ -467,7 +453,7 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     }
   }
 
-  @AfterClass
+  @AfterAll
   public static void tearDownClass()
   {
     BUFFER_POOLS.close();
@@ -494,7 +480,7 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     this.useVectorApi = useVectorApi;
   }
 
-  @Before
+  @BeforeEach
   public void initializeExpressionProcessing()
   {
     if (useVectorApi) {
@@ -504,7 +490,7 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     }
   }
 
-  @After
+  @AfterEach
   public void resetExpressionProcessing()
   {
     ExpressionProcessing.initializeForTests();
@@ -800,7 +786,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   public void testGroupByOnMissingColumn()
   {
     // Cannot vectorize due to extraction dimension spec.
-    cannotVectorize();
 
     GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
@@ -822,6 +807,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "missing-column");
   }
@@ -1252,16 +1245,17 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   @Test
   public void testGroupByWithOutputNameCollisions()
   {
-    expectedException.expect(IllegalArgumentException.class);
-    expectedException.expectMessage("[alias] already defined");
-
-    makeQueryBuilder()
-        .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
-        .setQuerySegmentSpec(QueryRunnerTestHelper.FIRST_TO_THIRD)
-        .setDimensions(new DefaultDimensionSpec("quality", "alias"))
-        .setAggregatorSpecs(QueryRunnerTestHelper.ROWS_COUNT, new LongSumAggregatorFactory("alias", "index"))
-        .setGranularity(QueryRunnerTestHelper.DAY_GRAN)
-        .build();
+    final IllegalArgumentException exception = Assertions.assertThrows(
+        IllegalArgumentException.class,
+        () -> makeQueryBuilder()
+            .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
+            .setQuerySegmentSpec(QueryRunnerTestHelper.FIRST_TO_THIRD)
+            .setDimensions(new DefaultDimensionSpec("quality", "alias"))
+            .setAggregatorSpecs(QueryRunnerTestHelper.ROWS_COUNT, new LongSumAggregatorFactory("alias", "index"))
+            .setGranularity(QueryRunnerTestHelper.DAY_GRAN)
+            .build()
+    );
+    Assertions.assertTrue(exception.getMessage().contains("[alias] already defined"));
   }
 
   @Test
@@ -1358,7 +1352,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     assumeTimeOrdered();
 
     // Cannot vectorize due to multi-value dimensions.
-    cannotVectorize();
 
     GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
@@ -1380,6 +1373,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         makeRow(query, "2011-04-01", "alias", "t", "rows", 4L, "idx", 420L)
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "multi-value-dim");
   }
@@ -1392,45 +1393,7 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
 
     final String dimName = "placementish";
 
-    if (!vectorize) {
-      expectedException.expect(RuntimeException.class);
-      expectedException.expectCause(CoreMatchers.instanceOf(ExecutionException.class));
-      expectedException.expectCause(
-          ThrowableCauseMatcher.hasCause(CoreMatchers.instanceOf(UnexpectedMultiValueDimensionException.class))
-      );
-      expectedException.expect(
-          new BaseMatcher<Throwable>()
-          {
-            @Override
-            public boolean matches(Object o)
-            {
-              final UnexpectedMultiValueDimensionException cause =
-                  (UnexpectedMultiValueDimensionException) ((Throwable) o).getCause().getCause();
-
-              return dimName.equals(cause.getDimensionName());
-            }
-
-            @Override
-            public void describeTo(Description description)
-            {
-              description.appendText("an UnexpectedMultiValueDimensionException with dimension [placementish]");
-            }
-          }
-      );
-      expectedException.expectMessage(
-          StringUtils.format(
-              "Encountered multi-value dimension [%s] that cannot be processed with '%s' set to false."
-              + " Consider setting '%s' to true in your query context.",
-              dimName,
-              GroupByQueryConfig.CTX_KEY_ENABLE_MULTI_VALUE_UNNESTING,
-              GroupByQueryConfig.CTX_KEY_ENABLE_MULTI_VALUE_UNNESTING
-          )
-      );
-    } else {
-      cannotVectorize();
-    }
-
-    GroupByQuery query = makeQueryBuilder()
+    final GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
         .setQuerySegmentSpec(QueryRunnerTestHelper.FIRST_TO_THIRD)
         .setDimensions(new DefaultDimensionSpec(dimName, "alias"))
@@ -1439,14 +1402,41 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         .overrideContext(ImmutableMap.of(GroupByQueryConfig.CTX_KEY_ENABLE_MULTI_VALUE_UNNESTING, false))
         .build();
 
-    GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
+    if (!vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getCause() instanceof ExecutionException);
+      Assertions.assertTrue(exception.getCause().getCause() instanceof UnexpectedMultiValueDimensionException);
+      Assertions.assertEquals(
+          dimName,
+          ((UnexpectedMultiValueDimensionException) exception.getCause().getCause()).getDimensionName()
+      );
+      Assertions.assertTrue(
+          exception.getMessage().contains(
+              StringUtils.format(
+                  "Encountered multi-value dimension [%s] that cannot be processed with '%s' set to false."
+                  + " Consider setting '%s' to true in your query context.",
+                  dimName,
+                  GroupByQueryConfig.CTX_KEY_ENABLE_MULTI_VALUE_UNNESTING,
+                  GroupByQueryConfig.CTX_KEY_ENABLE_MULTI_VALUE_UNNESTING
+              )
+          )
+      );
+    } else {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+    }
   }
 
   @Test
   public void testMultiValueDimensionAsArray()
   {
     // Cannot vectorize due to multi-value dimensions.
-    cannotVectorize();
 
     GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
@@ -1474,6 +1464,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         makeRow(query, "2011-04-01", "alias", new Object[]{"preferred", "t"}, "rows", 4L, "idx", 420L)
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "multi-value-dim-groupby-arrays");
   }
@@ -1482,7 +1480,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   public void testSingleValueDimensionAsArray()
   {
     // Cannot vectorize due to multi-value dimensions.
-    cannotVectorize();
 
     GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
@@ -1508,6 +1505,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "multi-value-dim-groupby-arrays");
   }
@@ -1516,7 +1521,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   public void testMultiValueDimensionAsArrayWithOtherDims()
   {
     // Cannot vectorize due to multi-value dimensions.
-    cannotVectorize();
 
     GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
@@ -1658,6 +1662,15 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    final GroupByQuery queryToRun = query;
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, queryToRun)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "multi-value-dims-groupby-arrays");
 
@@ -1702,12 +1715,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   @Test
   public void testMultiValueDimensionAsStringArrayWithoutExpression()
   {
-    if (!vectorize) {
-      expectedException.expect(RuntimeException.class);
-      expectedException.expectMessage("Not supported for multi-value dimensions");
-    }
-
-    cannotVectorize();
     GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
         .setQuerySegmentSpec(QueryRunnerTestHelper.FIRST_TO_THIRD)
@@ -1718,18 +1725,24 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         .setGranularity(QueryRunnerTestHelper.ALL_GRAN)
         .build();
 
-    GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
+    final RuntimeException exception = Assertions.assertThrows(
+        RuntimeException.class,
+        () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+    );
+    Assertions.assertTrue(exception.getMessage().contains("Not supported for multi-value dimensions"));
   }
 
   @Test
   public void testSingleValueDimensionAsStringArrayWithoutExpression()
   {
-    if (!vectorize) {
-      // cannot add exact class cast message due to discrepancies between various JDK versions
-      expectedException.expect(RuntimeException.class);
-    }
-    cannotVectorize();
-
     GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
         .setQuerySegmentSpec(QueryRunnerTestHelper.FIRST_TO_THIRD)
@@ -1740,22 +1753,18 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         .setGranularity(QueryRunnerTestHelper.ALL_GRAN)
         .build();
 
-    Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
-    List<ResultRow> expectedResults = ImmutableList.of(
-        makeRow(
-            query,
-            "2011-04-01",
-            "alias",
-            new Object[]{"preferred"},
-            "rows",
-            26L,
-            "idx",
-            12446L
-        ));
-    TestHelper.assertExpectedObjects(
-        expectedResults,
-        results,
-        "single-value-dims-groupby-arrays-as-string-arrays"
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
+    // Cannot add exact class cast message due to discrepancies between various JDK versions.
+    Assertions.assertThrows(
+        RuntimeException.class,
+        () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
     );
   }
 
@@ -1763,12 +1772,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   @Test
   public void testNumericDimAsStringArrayWithoutExpression()
   {
-    if (!vectorize) {
-      // cannot add exact class cast message due to discrepancies between various JDK versions
-      expectedException.expect(RuntimeException.class);
-    }
-
-    cannotVectorize();
     GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
         .setQuerySegmentSpec(QueryRunnerTestHelper.FIRST_TO_THIRD)
@@ -1779,19 +1782,25 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         .setGranularity(QueryRunnerTestHelper.ALL_GRAN)
         .build();
 
-    GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
+    // Cannot add exact class cast message due to discrepancies between various JDK versions.
+    Assertions.assertThrows(
+        RuntimeException.class,
+        () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+    );
   }
 
 
   @Test
   public void testMultiValueVirtualDimAsString()
   {
-    if (!vectorize) {
-      // cannot add exact class cast message due to discrepancies between various JDK versions
-      expectedException.expect(RuntimeException.class);
-    }
-
-    cannotVectorize();
     GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
         .setQuerySegmentSpec(QueryRunnerTestHelper.FIRST_TO_THIRD)
@@ -1811,13 +1820,24 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         .setGranularity(QueryRunnerTestHelper.ALL_GRAN)
         .build();
 
-    GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
+    // Cannot add exact class cast message due to discrepancies between various JDK versions.
+    Assertions.assertThrows(
+        RuntimeException.class,
+        () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+    );
   }
 
   @Test
   public void testExtractionStringSpecWithMultiValueVirtualDimAsInput()
   {
-    cannotVectorize();
     GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
         .setQuerySegmentSpec(QueryRunnerTestHelper.FIRST_TO_THIRD)
@@ -1863,6 +1883,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(
         expectedResults,
@@ -1875,12 +1903,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   @Test
   public void testExtractionStringArraySpecWithMultiValueVirtualDimAsInput()
   {
-    if (!vectorize) {
-      expectedException.expect(RuntimeException.class);
-      expectedException.expectMessage("Not supported for multi-value dimensions");
-    }
-
-    cannotVectorize();
     GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
         .setQuerySegmentSpec(QueryRunnerTestHelper.FIRST_TO_THIRD)
@@ -1900,13 +1922,24 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         .setGranularity(QueryRunnerTestHelper.ALL_GRAN)
         .build();
 
-    GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
+    final RuntimeException exception = Assertions.assertThrows(
+        RuntimeException.class,
+        () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+    );
+    Assertions.assertTrue(exception.getMessage().contains("Not supported for multi-value dimensions"));
   }
 
   @Test
   public void testVirtualColumnNumericTypeAsStringArray()
   {
-    cannotVectorize();
     GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
         .setQuerySegmentSpec(QueryRunnerTestHelper.FIRST_TO_THIRD)
@@ -1952,6 +1985,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         makeRow(query, "2011-04-01", "alias", new Object[]{"78.622547"}, "rows", 1L),
         makeRow(query, "2011-04-01", "alias", new Object[]{"97.387433"}, "rows", 1L)
     );
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(
         expectedResults,
@@ -1963,7 +2004,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   @Test
   public void testNestedGroupByWithStringArray()
   {
-    cannotVectorize();
     GroupByQuery inner = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
         .setQuerySegmentSpec(QueryRunnerTestHelper.FIRST_TO_THIRD)
@@ -2002,6 +2042,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         makeRow(outer, "2011-04-01", "alias_outer", new Object[]{"preferred", "t"}, "rows", 1L)
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, outer)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, outer);
     TestHelper.assertExpectedObjects(expectedResults, results, "multi-value-dim-nested-groupby-arrays");
   }
@@ -2009,7 +2057,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   @Test
   public void testNestedGroupByWithLongArrays()
   {
-    cannotVectorize();
     GroupByQuery inner = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
         .setQuerySegmentSpec(QueryRunnerTestHelper.FIRST_TO_THIRD)
@@ -2042,6 +2089,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
                 "rows", 1L
         ));
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, outer)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, outer);
     TestHelper.assertExpectedObjects(expectedResults, results, "long-nested-groupby-arrays");
   }
@@ -2049,7 +2104,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   @Test
   public void testGroupByWithLongArrays()
   {
-    cannotVectorize();
     GroupByQuery outer = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
         .setQuerySegmentSpec(QueryRunnerTestHelper.FIRST_TO_THIRD)
@@ -2105,6 +2159,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         makeRow(outer, "2011-04-01", "alias_outer", new Object[]{1522L}, "rows", 1L)
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, outer)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, outer);
     TestHelper.assertExpectedObjects(expectedResults, results, "long-groupby-arrays");
   }
@@ -2112,7 +2174,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   @Test
   public void testGroupByWithLongArraysDesc()
   {
-    cannotVectorize();
     GroupByQuery outer = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
         .setQuerySegmentSpec(QueryRunnerTestHelper.FIRST_TO_THIRD)
@@ -2169,6 +2230,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     );
     // reversing list
     Collections.reverse(expectedResults);
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, outer)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, outer);
     TestHelper.assertExpectedObjects(expectedResults, results, "long-groupby-arrays");
   }
@@ -2176,7 +2245,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   @Test
   public void testGroupByWithDoubleArrays()
   {
-    cannotVectorize();
     GroupByQuery outer = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
         .setQuerySegmentSpec(QueryRunnerTestHelper.FIRST_TO_THIRD)
@@ -2232,6 +2300,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         makeRow(outer, "2011-04-01", "alias_outer", new Object[]{1447.34116}, "rows", 1L),
         makeRow(outer, "2011-04-01", "alias_outer", new Object[]{1522.043733}, "rows", 1L)
     );
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, outer)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, outer);
     TestHelper.assertExpectedObjects(expectedResults, results, "long-groupby-arrays");
   }
@@ -2240,7 +2316,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   @Test
   public void testGroupByWithDoubleArraysDesc()
   {
-    cannotVectorize();
     GroupByQuery outer = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
         .setQuerySegmentSpec(QueryRunnerTestHelper.FIRST_TO_THIRD)
@@ -2298,6 +2373,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     );
     // reversing list
     Collections.reverse(expectedResults);
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, outer)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, outer);
     TestHelper.assertExpectedObjects(expectedResults, results, "long-groupby-arrays");
   }
@@ -2306,7 +2389,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   public void testTwoMultiValueDimensions()
   {
     // Cannot vectorize due to multi-value dimensions.
-    cannotVectorize();
 
     GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
@@ -2370,6 +2452,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "two-multi-value-dims");
   }
@@ -2378,7 +2468,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   public void testMultipleDimensionsOneOfWhichIsMultiValue1()
   {
     // Cannot vectorize due to multi-value dimensions.
-    cannotVectorize();
 
     GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
@@ -2609,6 +2698,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "one-multi-value-dim");
   }
@@ -2617,7 +2714,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   public void testMultipleDimensionsOneOfWhichIsMultiValueDifferentOrder()
   {
     // Cannot vectorize due to multi-value dimensions.
-    cannotVectorize();
 
     GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
@@ -2848,6 +2944,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "one-multi-value-dim-different-order");
   }
@@ -2967,13 +3071,11 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         .overrideContext(ImmutableMap.of("maxOnDiskStorage", 0, "bufferGrouperMaxSize", 1))
         .build();
 
-    List<ResultRow> expectedResults = null;
-    expectedException.expect(ResourceLimitExceededException.class);
-    expectedException.expectMessage("Not enough merge buffer memory to execute this query");
-
-
-    Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
-    TestHelper.assertExpectedObjects(expectedResults, results, "overide-maxOnDiskStorage");
+    final ResourceLimitExceededException exception = Assertions.assertThrows(
+        ResourceLimitExceededException.class,
+        () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+    );
+    Assertions.assertTrue(exception.getMessage().contains("Not enough merge buffer memory to execute this query"));
   }
 
   @Test
@@ -2991,17 +3093,19 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         .overrideContext(ImmutableMap.of("maxSpillFileCount", 1, GroupByQueryConfig.CTX_KEY_BUFFER_GROUPER_MAX_SIZE, 1))
         .build();
 
-    List<ResultRow> expectedResults = null;
-    expectedException.expect(ResourceLimitExceededException.class);
+    final String expectedMessage;
     if (config.getMaxOnDiskStorage().getBytes() > 0) {
       // The error message always mentions disk if you have spilling enabled (maxOnDiskStorage > 0)
-      expectedException.expectMessage("Maximum number of spill files reached for this query. Try raising druid.query.groupBy.maxSpillFileCount.");
+      expectedMessage = "Maximum number of spill files reached for this query. Try raising druid.query.groupBy.maxSpillFileCount.";
     } else {
-      expectedException.expectMessage("Not enough merge buffer memory to execute this query");
+      expectedMessage = "Not enough merge buffer memory to execute this query";
     }
 
-    Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
-    TestHelper.assertExpectedObjects(expectedResults, results, "disk-space");
+    final ResourceLimitExceededException exception = Assertions.assertThrows(
+        ResourceLimitExceededException.class,
+        () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+    );
+    Assertions.assertTrue(exception.getMessage().contains(expectedMessage));
   }
 
   @Test
@@ -3019,17 +3123,19 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         .overrideContext(ImmutableMap.of("maxOnDiskStorage", 1, GroupByQueryConfig.CTX_KEY_BUFFER_GROUPER_MAX_SIZE, 1))
         .build();
 
-    List<ResultRow> expectedResults = null;
-    expectedException.expect(ResourceLimitExceededException.class);
+    final String expectedMessage;
     if (config.getMaxOnDiskStorage().getBytes() > 0) {
       // The error message always mentions disk if you have spilling enabled (maxOnDiskStorage > 0)
-      expectedException.expectMessage("Not enough disk space to execute this query");
+      expectedMessage = "Not enough disk space to execute this query";
     } else {
-      expectedException.expectMessage("Not enough merge buffer memory to execute this query");
+      expectedMessage = "Not enough merge buffer memory to execute this query";
     }
 
-    Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
-    TestHelper.assertExpectedObjects(expectedResults, results, "disk-space");
+    final ResourceLimitExceededException exception = Assertions.assertThrows(
+        ResourceLimitExceededException.class,
+        () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+    );
+    Assertions.assertTrue(exception.getMessage().contains(expectedMessage));
   }
 
   @Test
@@ -3065,9 +3171,11 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         .overrideContext(ImmutableMap.of("maxOnDiskStorage", 0, "bufferGrouperMaxSize", 0))
         .build();
 
-    expectedException.expect(ResourceLimitExceededException.class);
-    expectedException.expectMessage("Not enough merge buffer memory to execute this query");
-    GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
+    final ResourceLimitExceededException exception = Assertions.assertThrows(
+        ResourceLimitExceededException.class,
+        () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+    );
+    Assertions.assertTrue(exception.getMessage().contains("Not enough merge buffer memory to execute this query"));
   }
 
   @Test
@@ -3077,7 +3185,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     assumeTimeOrdered();
 
     // Cannot vectorize due to extraction dimension spec.
-    cannotVectorize();
 
     Map<String, String> map = new HashMap<>();
     map.put("automotive", "automotive0");
@@ -3139,6 +3246,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         makeRow(query, "2011-04-02", "alias", "travel0", "rows", 1L, "idx", 126L)
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "rebucket-rename");
   }
@@ -3151,7 +3266,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     assumeTimeOrdered();
 
     // Cannot vectorize due to extraction dimension spec.
-    cannotVectorize();
 
     Map<String, String> map = new HashMap<>();
     map.put("automotive", "automotive0");
@@ -3213,6 +3327,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         makeRow(query, "2011-04-02", "alias", "travel0", "rows", 1L, "idx", 126L)
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "non-injective");
   }
@@ -3422,37 +3544,42 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     TestHelper.assertExpectedObjects(expectedResults, results, "uniques");
   }
 
-  @Test(expected = IllegalArgumentException.class)
+  @Test
   public void testGroupByWithUniquesAndPostAggWithSameName()
   {
-    GroupByQuery query = makeQueryBuilder()
-        .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
-        .setQuerySegmentSpec(QueryRunnerTestHelper.FIRST_TO_THIRD)
-        .setAggregatorSpecs(QueryRunnerTestHelper.ROWS_COUNT, new HyperUniquesAggregatorFactory(
-            "quality_uniques",
-            "quality_uniques"
-        ))
-        .setPostAggregatorSpecs(
-            Collections.singletonList(
-                new HyperUniqueFinalizingPostAggregator("quality_uniques", "quality_uniques")
-            )
-        )
-        .setGranularity(QueryRunnerTestHelper.ALL_GRAN)
-        .build();
+    Assertions.assertThrows(
+        IllegalArgumentException.class,
+        () -> {
+          final GroupByQuery query = makeQueryBuilder()
+              .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
+              .setQuerySegmentSpec(QueryRunnerTestHelper.FIRST_TO_THIRD)
+              .setAggregatorSpecs(QueryRunnerTestHelper.ROWS_COUNT, new HyperUniquesAggregatorFactory(
+                  "quality_uniques",
+                  "quality_uniques"
+              ))
+              .setPostAggregatorSpecs(
+                  Collections.singletonList(
+                      new HyperUniqueFinalizingPostAggregator("quality_uniques", "quality_uniques")
+                  )
+              )
+              .setGranularity(QueryRunnerTestHelper.ALL_GRAN)
+              .build();
+
+          final List<ResultRow> expectedResults = Collections.singletonList(
+              makeRow(
+                  query,
+                  "2011-04-01",
+                  "rows",
+                  26L,
+                  "quality_uniques",
+                  QueryRunnerTestHelper.UNIQUES_9
+              )
+          );
 
-    List<ResultRow> expectedResults = Collections.singletonList(
-        makeRow(
-            query,
-            "2011-04-01",
-            "rows",
-            26L,
-            "quality_uniques",
-            QueryRunnerTestHelper.UNIQUES_9
-        )
+          final Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
+          TestHelper.assertExpectedObjects(expectedResults, results, "unique-postagg-same-name");
+        }
     );
-
-    Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
-    TestHelper.assertExpectedObjects(expectedResults, results, "unique-postagg-same-name");
   }
 
   @Test
@@ -3638,7 +3765,7 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
 
     List<ResultRow> expectedResults = ImmutableList.of();
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
-    Assert.assertEquals(expectedResults, results);
+    Assertions.assertEquals(expectedResults, results);
   }
 
   @Test
@@ -3648,7 +3775,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     assumeTimeOrdered();
 
     // Cannot vectorize due to extraction dimension spec.
-    cannotVectorize();
 
     final ExtractionFn nullExtractionFn = new RegexDimExtractionFn("(\\w{1})", false, null)
     {
@@ -3692,6 +3818,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         makeRow(query, "2011-04-02", "alias", "t", "rows", 2L, "idx", 223L)
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     TestHelper.assertExpectedObjects(
         expectedResults,
         GroupByQueryRunnerTestHelper.runQuery(factory, runner, query),
@@ -3700,7 +3834,7 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   }
 
   @Test
-  @Ignore
+  @Disabled
   /**
    * This test exists only to show what the current behavior is and not necessarily to define that this is
    * correct behavior.  In fact, the behavior when returning the empty string from a DimExtractionFn is, by
@@ -4282,7 +4416,7 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     );
   }
 
-  @Test(expected = IllegalArgumentException.class)
+  @Test
   public void testMergeResultsWithNegativeLimit()
   {
     GroupByQuery.Builder builder = makeQueryBuilder()
@@ -4293,7 +4427,7 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         .setGranularity(new PeriodGranularity(new Period("P1M"), null, null))
         .setLimit(-1);
 
-    builder.build();
+    Assertions.assertThrows(IllegalArgumentException.class, builder::build);
   }
 
   @Test
@@ -4966,7 +5100,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     assumeTimeOrdered();
 
     // Cannot vectorize due to extraction dimension spec.
-    cannotVectorize();
 
     Map<String, String> map = new HashMap<>();
     map.put("automotive", "health105");
@@ -5016,6 +5149,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         makeRow(query, "2011-04-02", "alias", "travel555", "rows", 1L, "idx", 126L)
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "alphanumeric-dimension-order");
   }
@@ -5027,7 +5168,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     assumeTimeOrdered();
 
     // Cannot vectorize due to extraction dimension spec.
-    cannotVectorize();
 
     Map<String, String> map = new HashMap<>();
     map.put("automotive", "9");
@@ -5076,11 +5216,19 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         makeRow(query, "2011-04-01", "alias", "6", "rows", 1L, "idx", 120L)
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "lookup-limit");
   }
 
-  @Ignore
+  @Disabled
   @Test
   // This is a test to verify per limit groupings, but Druid currently does not support this functionality. At a point
   // in time when Druid does support this, we can re-evaluate this test.
@@ -5117,11 +5265,11 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
 
     final Object next1 = resultsIter.next();
     Object expectedNext1 = expectedResultsIter.next();
-    Assert.assertEquals("order-limit", expectedNext1, next1);
+    Assertions.assertEquals(expectedNext1, next1, "order-limit");
 
     final Object next2 = resultsIter.next();
     Object expectedNext2 = expectedResultsIter.next();
-    Assert.assertNotEquals("order-limit", expectedNext2, next2);
+    Assertions.assertNotEquals(expectedNext2, next2, "order-limit");
   }
 
   @Test
@@ -6303,72 +6451,78 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
 
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     Row result = Iterables.getOnlyElement(results).toMapBasedRow(query);
-    Assert.assertEquals(51.0d, result.getMetric("meanOnDouble").doubleValue(), 0.0001d);
+    Assertions.assertEquals(51.0d, result.getMetric("meanOnDouble").doubleValue(), 0.0001d);
   }
 
   @Test
   public void testGroupByTimeExtractionNamedUnderUnderTime()
   {
-    expectedException.expect(IAE.class);
-    expectedException.expectMessage(
-        "'__time' cannot be used as an output name for dimensions, aggregators, or post-aggregators."
-    );
-
-    makeQueryBuilder()
-        .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
-        .setQuerySegmentSpec(QueryRunnerTestHelper.FULL_ON_INTERVAL_SPEC)
-        .setDimensions(
-            new DefaultDimensionSpec("market", "market"),
-            new ExtractionDimensionSpec(
-                ColumnHolder.TIME_COLUMN_NAME,
-                ColumnHolder.TIME_COLUMN_NAME,
-                new TimeFormatExtractionFn("EEEE", null, null, null, false)
+    final IAE exception = Assertions.assertThrows(
+        IAE.class,
+        () -> makeQueryBuilder()
+            .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
+            .setQuerySegmentSpec(QueryRunnerTestHelper.FULL_ON_INTERVAL_SPEC)
+            .setDimensions(
+                new DefaultDimensionSpec("market", "market"),
+                new ExtractionDimensionSpec(
+                    ColumnHolder.TIME_COLUMN_NAME,
+                    ColumnHolder.TIME_COLUMN_NAME,
+                    new TimeFormatExtractionFn("EEEE", null, null, null, false)
+                )
             )
-        )
-        .setAggregatorSpecs(QueryRunnerTestHelper.ROWS_COUNT, QueryRunnerTestHelper.INDEX_DOUBLE_SUM)
-        .setPostAggregatorSpecs(Collections.singletonList(QueryRunnerTestHelper.ADD_ROWS_INDEX_CONSTANT))
-        .setGranularity(QueryRunnerTestHelper.ALL_GRAN)
-        .setDimFilter(
-            new OrDimFilter(
-                Arrays.asList(
-                    new SelectorDimFilter("market", "spot", null),
-                    new SelectorDimFilter("market", "upfront", null)
+            .setAggregatorSpecs(QueryRunnerTestHelper.ROWS_COUNT, QueryRunnerTestHelper.INDEX_DOUBLE_SUM)
+            .setPostAggregatorSpecs(Collections.singletonList(QueryRunnerTestHelper.ADD_ROWS_INDEX_CONSTANT))
+            .setGranularity(QueryRunnerTestHelper.ALL_GRAN)
+            .setDimFilter(
+                new OrDimFilter(
+                    Arrays.asList(
+                        new SelectorDimFilter("market", "spot", null),
+                        new SelectorDimFilter("market", "upfront", null)
+                    )
                 )
             )
+            .setLimitSpec(new DefaultLimitSpec(ImmutableList.of(), 1))
+            .build()
+    );
+    Assertions.assertTrue(
+        exception.getMessage().contains(
+            "'__time' cannot be used as an output name for dimensions, aggregators, or post-aggregators."
         )
-        .setLimitSpec(new DefaultLimitSpec(ImmutableList.of(), 1))
-        .build();
+    );
   }
 
   @Test
   public void testGroupByWithUnderUnderTimeAsDimensionNameWithHavingAndLimit()
   {
-    expectedException.expect(IAE.class);
-    expectedException.expectMessage(
-        "'__time' cannot be used as an output name for dimensions, aggregators, or post-aggregators."
-    );
-
-    makeQueryBuilder()
-        .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
-        .setQuerySegmentSpec(QueryRunnerTestHelper.FIRST_TO_THIRD)
-        .setDimensions(new DefaultDimensionSpec("quality", "__time"))
-        .setAggregatorSpecs(QueryRunnerTestHelper.ROWS_COUNT, new LongSumAggregatorFactory("idx", "index"))
-        .setGranularity(QueryRunnerTestHelper.DAY_GRAN)
-        .setHavingSpec(
-            new OrHavingSpec(
-                ImmutableList.of(
-                    new DimensionSelectorHavingSpec("__time", "automotive", null),
-                    new DimensionSelectorHavingSpec("__time", "business", null)
+    final IAE exception = Assertions.assertThrows(
+        IAE.class,
+        () -> makeQueryBuilder()
+            .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
+            .setQuerySegmentSpec(QueryRunnerTestHelper.FIRST_TO_THIRD)
+            .setDimensions(new DefaultDimensionSpec("quality", "__time"))
+            .setAggregatorSpecs(QueryRunnerTestHelper.ROWS_COUNT, new LongSumAggregatorFactory("idx", "index"))
+            .setGranularity(QueryRunnerTestHelper.DAY_GRAN)
+            .setHavingSpec(
+                new OrHavingSpec(
+                    ImmutableList.of(
+                        new DimensionSelectorHavingSpec("__time", "automotive", null),
+                        new DimensionSelectorHavingSpec("__time", "business", null)
+                    )
                 )
             )
-        )
-        .setLimitSpec(
-            new DefaultLimitSpec(
-                ImmutableList.of(new OrderByColumnSpec("__time", OrderByColumnSpec.Direction.DESCENDING)),
-                null
+            .setLimitSpec(
+                new DefaultLimitSpec(
+                    ImmutableList.of(new OrderByColumnSpec("__time", OrderByColumnSpec.Direction.DESCENDING)),
+                    null
+                )
             )
+            .build()
+    );
+    Assertions.assertTrue(
+        exception.getMessage().contains(
+            "'__time' cannot be used as an output name for dimensions, aggregators, or post-aggregators."
         )
-        .build();
+    );
   }
 
   @Test
@@ -6393,7 +6547,7 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         .build();
 
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
-    Assert.assertFalse(results.iterator().hasNext());
+    Assertions.assertFalse(results.iterator().hasNext());
   }
 
   @Test
@@ -6992,7 +7146,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     assumeTimeOrdered();
 
     // Cannot vectorize due to javascript functionality.
-    cannotVectorize();
 
     final GroupByQuery subquery = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
@@ -7167,6 +7320,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     );
 
     // Subqueries are handled by the ToolChest
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "subquery-multi-aggs");
   }
@@ -8716,7 +8877,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   public void testGroupByWithTimeColumn()
   {
     // Cannot vectorize due to javascript aggregator.
-    cannotVectorize();
 
     GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
@@ -8742,6 +8902,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "time");
   }
@@ -8750,7 +8918,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   public void testGroupByTimeExtraction()
   {
     // Cannot vectorize due to extraction dimension spec.
-    cannotVectorize();
 
     GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
@@ -8975,6 +9142,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "time-extraction");
   }
@@ -8984,7 +9159,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   public void testGroupByTimeExtractionWithNulls()
   {
     // Cannot vectorize due to extraction dimension specs.
-    cannotVectorize();
 
     final DimExtractionFn nullWednesdays = new DimExtractionFn()
     {
@@ -9242,6 +9416,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "time-extraction");
   }
@@ -10073,7 +10255,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     assumeTimeOrdered();
 
     // Cannot vectorize due to extraction dimension spec.
-    cannotVectorize();
 
     String helloJsFn = "function(str) { return 'hello' }";
     ExtractionFn helloFn = new JavaScriptExtractionFn(helloJsFn, false, JavaScriptConfig.getEnabledInstance());
@@ -10157,6 +10338,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "cardinality-agg");
   }
@@ -10375,7 +10564,7 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         .setGranularity(QueryRunnerTestHelper.DAY_GRAN)
         .build();
 
-    Assert.assertEquals(Functions.<Sequence<ResultRow>>identity(), query.getLimitSpec().build(query));
+    Assertions.assertEquals(Functions.<Sequence<ResultRow>>identity(), query.getLimitSpec().build(query));
 
     List<ResultRow> expectedResults = Arrays.asList(
         makeRow(
@@ -10419,9 +10608,11 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         .setGranularity(QueryRunnerTestHelper.ALL_GRAN)
         .build();
 
-    expectedException.expect(DruidException.class);
-    expectedException.expectMessage("Type [COMPLEX<hyperUnique>] is not groupable");
-    GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
+    final DruidException exception = Assertions.assertThrows(
+        DruidException.class,
+        () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+    );
+    Assertions.assertTrue(exception.getMessage().contains("Type [COMPLEX<hyperUnique>] is not groupable"));
   }
 
   @Test
@@ -10441,7 +10632,7 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         .setGranularity(QueryRunnerTestHelper.ALL_GRAN)
         .build();
 
-    Assert.assertNotEquals(Functions.<Sequence<ResultRow>>identity(), query.getLimitSpec().build(query));
+    Assertions.assertNotEquals(Functions.<Sequence<ResultRow>>identity(), query.getLimitSpec().build(query));
 
     List<ResultRow> expectedResults = Arrays.asList(
         makeRow(
@@ -10476,7 +10667,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     assumeTimeOrdered();
 
     // Cannot vectorize due to extraction dimension spec.
-    cannotVectorize();
 
     String jsFn = "function(str) { return 'super-' + str; }";
     ExtractionFn jsExtractionFn = new JavaScriptExtractionFn(jsFn, false, JavaScriptConfig.getEnabledInstance());
@@ -10512,6 +10702,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
             166L
         )
     );
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "long-extraction");
   }
@@ -10564,7 +10762,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     assumeTimeOrdered();
 
     // Cannot vectorize due to extraction dimension spec.
-    cannotVectorize();
 
     String jsFn = "function(str) { return 'super-' + str; }";
     ExtractionFn jsExtractionFn = new JavaScriptExtractionFn(jsFn, false, JavaScriptConfig.getEnabledInstance());
@@ -10600,6 +10797,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
             166L
         )
     );
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "long-extraction");
   }
@@ -10624,7 +10829,7 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         .setGranularity(QueryRunnerTestHelper.DAY_GRAN)
         .build();
 
-    Assert.assertEquals(Functions.<Sequence<ResultRow>>identity(), query.getLimitSpec().build(query));
+    Assertions.assertEquals(Functions.<Sequence<ResultRow>>identity(), query.getLimitSpec().build(query));
 
     List<ResultRow> expectedResults = Arrays.asList(
         makeRow(
@@ -10670,7 +10875,7 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         .setGranularity(QueryRunnerTestHelper.ALL_GRAN)
         .build();
 
-    Assert.assertNotEquals(Functions.<Sequence<ResultRow>>identity(), query.getLimitSpec().build(query));
+    Assertions.assertNotEquals(Functions.<Sequence<ResultRow>>identity(), query.getLimitSpec().build(query));
 
     List<ResultRow> expectedResults = Arrays.asList(
         makeRow(
@@ -10715,7 +10920,7 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         .setGranularity(QueryRunnerTestHelper.ALL_GRAN)
         .build();
 
-    Assert.assertNotEquals(Functions.<Sequence<ResultRow>>identity(), query.getLimitSpec().build(query));
+    Assertions.assertNotEquals(Functions.<Sequence<ResultRow>>identity(), query.getLimitSpec().build(query));
 
     List<ResultRow> expectedResults = Arrays.asList(
         makeRow(
@@ -10750,7 +10955,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     assumeTimeOrdered();
 
     // Cannot vectorize due to extraction dimension spec.
-    cannotVectorize();
 
     String jsFn = "function(str) { return 'super-' + str; }";
     ExtractionFn jsExtractionFn = new JavaScriptExtractionFn(jsFn, false, JavaScriptConfig.getEnabledInstance());
@@ -10789,6 +10993,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "float");
   }
@@ -10953,7 +11165,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   public void testGroupByNumericStringsAsNumericWithDecoration()
   {
     // Cannot vectorize due to regex-filtered dimension spec.
-    cannotVectorize();
 
     // rows with `technology` have `170000` in the qualityNumericString field
     RegexFilteredDimensionSpec regexSpec = new RegexFilteredDimensionSpec(
@@ -10996,6 +11207,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "numeric-string");
   }
@@ -11004,7 +11223,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   public void testGroupByDecorationOnNumerics()
   {
     // Cannot vectorize due to filtered dimension spec.
-    cannotVectorize();
 
     RegexFilteredDimensionSpec regexSpec = new RegexFilteredDimensionSpec(
         new DefaultDimensionSpec("qualityLong", "ql", ColumnType.LONG),
@@ -11042,6 +11260,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "numeric");
   }
@@ -11126,7 +11352,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     // Granularity != ALL requires time-ordering.
     assumeTimeOrdered();
 
-    cannotVectorize();
 
     // Following extractionFn will generate null value for one kind of quality
     ExtractionFn extractionFn = new SearchQuerySpecDimExtractionFn(new ContainsSearchQuerySpec("1200", false));
@@ -11200,6 +11425,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, outerQuery)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, outerQuery);
     TestHelper.assertExpectedObjects(expectedResults, results, "numerics");
   }
@@ -11294,7 +11527,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     assumeTimeOrdered();
 
     // Cannot vectorize due to extraction dimension spec.
-    cannotVectorize();
 
     ExtractionFn strlenFn = StrlenExtractionFn.instance();
 
@@ -11335,6 +11567,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "string-long");
   }
@@ -11346,7 +11586,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     assumeTimeOrdered();
 
     // Cannot vectorize due to javascript aggregators.
-    cannotVectorize();
 
     GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
@@ -11406,6 +11645,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "numeric-dims");
   }
@@ -11417,7 +11664,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     assumeTimeOrdered();
 
     // Cannot vectorize due to extraction dimension spec.
-    cannotVectorize();
 
     String jsFn = "function(obj) { return obj; }";
     ExtractionFn jsExtractionFn = new JavaScriptExtractionFn(jsFn, false, JavaScriptConfig.getEnabledInstance());
@@ -11452,6 +11698,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         makeRow(outerQuery, "2011-04-01", "alias", "technology", "qf_outer", 17000.0f, "rows", 2L)
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, outerQuery)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, outerQuery);
     TestHelper.assertExpectedObjects(expectedResults, results, "extraction-fn");
   }
@@ -11463,7 +11717,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     assumeTimeOrdered();
 
     // Cannot vectorize due to extraction dimension spec.
-    cannotVectorize();
 
     GroupByQuery subquery = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
@@ -11498,6 +11751,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         makeRow(outerQuery, "2011-04-01", "alias", "technology", "time_week", 1301270400000L, "rows", 2L)
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, outerQuery)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, outerQuery);
     TestHelper.assertExpectedObjects(expectedResults, results, "extraction-fn");
   }
@@ -11597,7 +11858,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   public void testGroupByLimitPushDownWithLongDimensionNotInLimitSpec()
   {
     // Cannot vectorize due to extraction dimension spec.
-    cannotVectorize();
 
     GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
@@ -11665,6 +11925,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "order-limit");
   }
@@ -11673,7 +11941,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   public void testMergeLimitPushDownResultsWithLongDimensionNotInLimitSpec()
   {
     // Cannot vectorize due to extraction dimension spec.
-    cannotVectorize();
 
     GroupByQuery.Builder builder = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
@@ -11733,6 +12000,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         makeRow(allGranQuery, "2011-04-02", "qualityLen", 13L, "rows", 2L)
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> mergedRunner.run(QueryPlus.wrap(GroupByQueryRunnerTestHelper.populateResourceId(allGranQuery)))
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     TestHelper.assertExpectedObjects(
         allGranExpectedResults,
         mergedRunner.run(QueryPlus.wrap(GroupByQueryRunnerTestHelper.populateResourceId(allGranQuery))),
@@ -12099,9 +12374,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   @Test
   public void testGroupByLimitPushDownPostAggNotSupported()
   {
-    expectedException.expect(UnsupportedOperationException.class);
-    expectedException.expectMessage("Limit push down when sorting by a post aggregator is not supported.");
-
     GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
         .setGranularity(QueryRunnerTestHelper.ALL_GRAN).setDimensions(new DefaultDimensionSpec(
@@ -12129,7 +12401,13 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
         .build();
 
-    GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
+    final UnsupportedOperationException exception = Assertions.assertThrows(
+        UnsupportedOperationException.class,
+        () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+    );
+    Assertions.assertTrue(
+        exception.getMessage().contains("Limit push down when sorting by a post aggregator is not supported.")
+    );
   }
 
   @Test
@@ -12164,7 +12442,7 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         .build();
 
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
-    Assert.assertFalse(results.iterator().hasNext());
+    Assertions.assertFalse(results.iterator().hasNext());
   }
 
 
@@ -12321,9 +12599,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   @Test
   public void testRejectForceLimitPushDownWithHaving()
   {
-    expectedException.expect(IAE.class);
-    expectedException.expectMessage("Cannot force limit push down when a having spec is present.");
-
     final GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
         .setGranularity(QueryRunnerTestHelper.ALL_GRAN)
@@ -12339,7 +12614,8 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         .overrideContext(ImmutableMap.of(GroupByQueryConfig.CTX_KEY_FORCE_LIMIT_PUSH_DOWN, true))
         .setHavingSpec(new GreaterThanHavingSpec("rows", 10))
         .build();
-    query.isApplyLimitPushDown();
+    final IAE exception = Assertions.assertThrows(IAE.class, query::isApplyLimitPushDown);
+    Assertions.assertTrue(exception.getMessage().contains("Cannot force limit push down when a having spec is present."));
   }
 
   @Test
@@ -12349,7 +12625,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     assumeTimeOrdered();
 
     // Cannot vectorize due to extraction dimension spec.
-    cannotVectorize();
 
     GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
@@ -12378,6 +12653,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
 
     QueryRunner<ResultRow> mergingRunner = factory.mergeRunners(Execs.directExecutor(), ImmutableList.of(ceqr));
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, mergingRunner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, mergingRunner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "type-conversion");
   }
@@ -12608,7 +12891,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     assumeTimeOrdered();
 
     // expression agg not yet vectorized
-    cannotVectorize();
 
     GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
@@ -12835,6 +13117,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "groupBy");
   }
@@ -12842,7 +13132,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   @Test
   public void testGroupByWithExpressionAggregatorWithComplex()
   {
-    cannotVectorize();
     final GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
         .setQuerySegmentSpec(QueryRunnerTestHelper.FULL_ON_INTERVAL_SPEC)
@@ -12876,6 +13165,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     List<ResultRow> expectedResults = Collections.singletonList(
         makeRow(query, "1970-01-01", "car", QueryRunnerTestHelper.UNIQUES_9, "carExpr", QueryRunnerTestHelper.UNIQUES_9)
     );
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "subquery-cardinality");
   }
@@ -12935,7 +13232,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     assumeTimeOrdered();
 
     // expression agg not yet vectorized
-    cannotVectorize();
 
     GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
@@ -13214,6 +13510,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "groupBy");
   }
@@ -13225,7 +13529,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     assumeTimeOrdered();
 
     // expression agg not yet vectorized
-    cannotVectorize();
 
     GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.DATA_SOURCE)
@@ -13400,6 +13703,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "groupBy");
   }
@@ -13510,7 +13821,6 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   @Test
   public void testGroupByFloatMinExpressionVsVirtualColumnWithExplicitStringVirtualColumnTypedInput()
   {
-    cannotVectorize();
     // SQL should never plan anything like this, where the virtual column type mismatches the aggregator type
     // but it still works ok
     GroupByQuery query = makeQueryBuilder()
@@ -13559,6 +13869,14 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> GroupByQueryRunnerTestHelper.runQuery(factory, runner, query)
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = GroupByQueryRunnerTestHelper.runQuery(factory, runner, query);
     TestHelper.assertExpectedObjects(expectedResults, results, "groupBy");
   }
@@ -13766,7 +14084,7 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
   {
     try (final CursorHolder cursorHolder =
              originalRunner.getSegment().as(CursorFactory.class).makeCursorHolder(CursorBuildSpec.FULL_SCAN)) {
-      Assume.assumeTrue(Cursors.getTimeOrdering(cursorHolder.getOrdering()) == Order.ASCENDING);
+      Assumptions.assumeTrue(Cursors.getTimeOrdering(cursorHolder.getOrdering()) == Order.ASCENDING);
     }
   }
 
@@ -13779,26 +14097,18 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
                        .build();
   }
 
-  private void cannotVectorize()
-  {
-    if (vectorize) {
-      expectedException.expect(RuntimeException.class);
-      expectedException.expectMessage("Cannot vectorize!");
-    }
-  }
-
   private void verifyGroupByMetricsForSmallBufferConfig(boolean skipMergeDictionaryMetric)
   {
     if (!config.toString().equals(V2_SMALL_BUFFER_CONFIG.toString())) {
       return;
     }
     GroupByStatsProvider.AggregateStats aggregateStats = statsProvider.getStatsSince();
-    Assert.assertEquals(1, aggregateStats.getSpilledQueries());
-    Assert.assertTrue(aggregateStats.getSpilledBytes() > 0);
-    Assert.assertEquals(1, aggregateStats.getMergeBufferQueries());
-    Assert.assertTrue(aggregateStats.getMergeBufferAcquisitionTimeNs() > 0);
+    Assertions.assertEquals(1, aggregateStats.getSpilledQueries());
+    Assertions.assertTrue(aggregateStats.getSpilledBytes() > 0);
+    Assertions.assertEquals(1, aggregateStats.getMergeBufferQueries());
+    Assertions.assertTrue(aggregateStats.getMergeBufferAcquisitionTimeNs() > 0);
     if (!skipMergeDictionaryMetric) {
-      Assert.assertTrue(aggregateStats.getMergeDictionarySize() > 0);
+      Assertions.assertTrue(aggregateStats.getMergeDictionarySize() > 0);
     }
   }
 
@@ -13807,4 +14117,3 @@ public class GroupByQueryRunnerTest extends InitializedNullHandlingTest
     verifyGroupByMetricsForSmallBufferConfig(false);
   }
 }
-
diff --git a/processing/src/test/java/org/apache/druid/query/groupby/GroupByTimeseriesQueryRunnerTest.java b/processing/src/test/java/org/apache/druid/query/groupby/GroupByTimeseriesQueryRunnerTest.java
index 9b682ba87b9..90a507d80a8 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/GroupByTimeseriesQueryRunnerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/GroupByTimeseriesQueryRunnerTest.java
@@ -54,12 +54,12 @@ import org.apache.druid.segment.VirtualColumns;
 import org.apache.druid.segment.column.ColumnType;
 import org.apache.druid.segment.virtual.ExpressionVirtualColumn;
 import org.joda.time.DateTime;
-import org.junit.AfterClass;
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+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 org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -71,18 +71,19 @@ import java.util.Map;
 /**
  * This class is for testing both timeseries and groupBy queries with the same set of queries.
  */
-@RunWith(Parameterized.class)
+@ParameterizedClass
+@MethodSource("constructorFeeder")
 public class GroupByTimeseriesQueryRunnerTest extends TimeseriesQueryRunnerTest
 {
   private static TestGroupByBuffers BUFFER_POOLS = null;
 
-  @BeforeClass
+  @BeforeAll
   public static void setUpClass()
   {
     BUFFER_POOLS = TestGroupByBuffers.createDefault();
   }
 
-  @AfterClass
+  @AfterAll
   public static void tearDownClass()
   {
     BUFFER_POOLS.close();
@@ -90,7 +91,6 @@ public class GroupByTimeseriesQueryRunnerTest extends TimeseriesQueryRunnerTest
   }
 
   @SuppressWarnings("unchecked")
-  @Parameterized.Parameters(name = "{0}, vectorize = {1}, useVectorApi = {2}")
   public static Iterable<Object[]> constructorFeeder()
   {
     setUpClass();
@@ -226,16 +226,16 @@ public class GroupByTimeseriesQueryRunnerTest extends TimeseriesQueryRunnerTest
     Iterable<Result<TimeseriesResultValue>> results = runner.run(QueryPlus.wrap(query)).toList();
     Result<TimeseriesResultValue> result = results.iterator().next();
 
-    Assert.assertEquals(expectedEarliest, result.getTimestamp());
-    Assert.assertFalse(
-        StringUtils.format("Timestamp[%s] > expectedLast[%s]", result.getTimestamp(), expectedLast),
-        result.getTimestamp().isAfter(expectedLast)
+    Assertions.assertEquals(expectedEarliest, result.getTimestamp());
+    Assertions.assertFalse(
+        result.getTimestamp().isAfter(expectedLast),
+        StringUtils.format("Timestamp[%s] > expectedLast[%s]", result.getTimestamp(), expectedLast)
     );
 
     final TimeseriesResultValue value = result.getValue();
 
-    Assert.assertEquals(result.toString(), 1870.061029, value.getDoubleMetric("maxIndex"), 1870.061029 * 1e-6);
-    Assert.assertEquals(result.toString(), 59.021022, value.getDoubleMetric("minIndex"), 59.021022 * 1e-6);
+    Assertions.assertEquals(1870.061029, value.getDoubleMetric("maxIndex"), 1870.061029 * 1e-6, result.toString());
+    Assertions.assertEquals(59.021022, value.getDoubleMetric("minIndex"), 59.021022 * 1e-6, result.toString());
   }
 
   // GroupBy handles timestamps differently when granularity is ALL
@@ -265,25 +265,25 @@ public class GroupByTimeseriesQueryRunnerTest extends TimeseriesQueryRunnerTest
     Iterable<Result<TimeseriesResultValue>> results = runner.run(QueryPlus.wrap(query)).toList();
     Result<TimeseriesResultValue> result = results.iterator().next();
 
-    Assert.assertEquals(expectedEarliest, result.getTimestamp());
-    Assert.assertFalse(
-        StringUtils.format("Timestamp[%s] > expectedLast[%s]", result.getTimestamp(), expectedLast),
-        result.getTimestamp().isAfter(expectedLast)
+    Assertions.assertEquals(expectedEarliest, result.getTimestamp());
+    Assertions.assertFalse(
+        result.getTimestamp().isAfter(expectedLast),
+        StringUtils.format("Timestamp[%s] > expectedLast[%s]", result.getTimestamp(), expectedLast)
     );
-    Assert.assertEquals(59L, (long) result.getValue().getLongMetric(QueryRunnerTestHelper.LONG_MIN_INDEX_METRIC));
-    Assert.assertEquals(1870, (long) result.getValue().getLongMetric(QueryRunnerTestHelper.LONG_MAX_INDEX_METRIC));
-    Assert.assertEquals(
+    Assertions.assertEquals(59L, (long) result.getValue().getLongMetric(QueryRunnerTestHelper.LONG_MIN_INDEX_METRIC));
+    Assertions.assertEquals(1870, (long) result.getValue().getLongMetric(QueryRunnerTestHelper.LONG_MAX_INDEX_METRIC));
+    Assertions.assertEquals(
         59.021022D,
         result.getValue().getDoubleMetric(QueryRunnerTestHelper.DOUBLE_MIN_INDEX_METRIC),
         0
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         1870.061029D,
         result.getValue().getDoubleMetric(QueryRunnerTestHelper.DOUBLE_MAX_INDEX_METRIC),
         0
     );
-    Assert.assertEquals(59.021023F, result.getValue().getFloatMetric(QueryRunnerTestHelper.FLOAT_MIN_INDEX_METRIC), 0);
-    Assert.assertEquals(1870.061F, result.getValue().getFloatMetric(QueryRunnerTestHelper.FLOAT_MAX_INDEX_METRIC), 0);
+    Assertions.assertEquals(59.021023F, result.getValue().getFloatMetric(QueryRunnerTestHelper.FLOAT_MIN_INDEX_METRIC), 0);
+    Assertions.assertEquals(1870.061F, result.getValue().getFloatMetric(QueryRunnerTestHelper.FLOAT_MAX_INDEX_METRIC), 0);
   }
 
   @Override
@@ -359,11 +359,6 @@ public class GroupByTimeseriesQueryRunnerTest extends TimeseriesQueryRunnerTest
   @Override
   public void testTimeseriesWithExpressionAggregatorTooBig()
   {
-    cannotVectorize();
-    if (!vectorize) {
-      // size bytes when it overshoots varies slightly between algorithms
-      expectedException.expectMessage("Unable to serialize [ARRAY<STRING>]");
-    }
     TimeseriesQuery query = Druids.newTimeseriesQueryBuilder()
                                   .dataSource(QueryRunnerTestHelper.DATA_SOURCE)
                                   .granularity(Granularities.DAY)
@@ -392,7 +387,23 @@ public class GroupByTimeseriesQueryRunnerTest extends TimeseriesQueryRunnerTest
                                   .context(makeContext())
                                   .build();
 
-    runner.run(QueryPlus.wrap(query)).toList();
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> runner.run(QueryPlus.wrap(query)).toList()
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
+    // Size bytes when it overshoots varies slightly between algorithms.
+    final Throwable exception = Assertions.assertThrows(
+        Throwable.class,
+        () -> runner.run(QueryPlus.wrap(query)).toList()
+    );
+    Assertions.assertTrue(
+        exception.getMessage() != null
+        && exception.getMessage().contains("Unable to serialize [ARRAY<STRING>]")
+    );
   }
 
   @Override
@@ -414,6 +425,6 @@ public class GroupByTimeseriesQueryRunnerTest extends TimeseriesQueryRunnerTest
     Iterable<Result<TimeseriesResultValue>> results = runner.run(QueryPlus.wrap(query))
                                                             .toList();
     // group by query results are empty instead of day bucket results with zeros and nulls
-    Assert.assertEquals(Collections.emptyList(), results);
+    Assertions.assertEquals(Collections.emptyList(), results);
   }
 }
diff --git a/processing/src/test/java/org/apache/druid/query/groupby/NestedDataGroupByQueryTest.java b/processing/src/test/java/org/apache/druid/query/groupby/NestedDataGroupByQueryTest.java
index e6137233eea..6d2dc1a2aa9 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/NestedDataGroupByQueryTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/NestedDataGroupByQueryTest.java
@@ -47,13 +47,13 @@ import org.apache.druid.segment.virtual.NestedFieldVirtualColumn;
 import org.apache.druid.segment.virtual.NestedMergeVirtualColumn;
 import org.apache.druid.segment.virtual.NestedObjectVirtualColumn;
 import org.apache.druid.testing.InitializedNullHandlingTest;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+import org.apache.druid.testing.TemporaryFolderExtension;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+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 java.io.IOException;
 import java.util.ArrayList;
@@ -65,29 +65,31 @@ import java.util.Objects;
 import java.util.function.BiFunction;
 import java.util.function.Supplier;
 
-@RunWith(Parameterized.class)
+@ParameterizedClass
+
+@MethodSource("constructorFeeder")
 public class NestedDataGroupByQueryTest extends InitializedNullHandlingTest
 {
   private static final Logger LOG = new Logger(NestedDataGroupByQueryTest.class);
 
-  @Rule
-  public final TemporaryFolder tempFolder = new TemporaryFolder();
+  @RegisterExtension
+  public final TemporaryFolderExtension tempFolder = new TemporaryFolderExtension();
 
   private final Closer closer;
   private final QueryContexts.Vectorize vectorize;
   private final AggregationTestHelper helper;
-  private final BiFunction<TemporaryFolder, Closer, List<Segment>> segmentsGenerator;
+  private final BiFunction<TemporaryFolderExtension, Closer, List<Segment>> segmentsGenerator;
   private final String segmentsName;
 
   public NestedDataGroupByQueryTest(
       GroupByQueryConfig config,
-      BiFunction<TemporaryFolder, Closer, List<Segment>> segmentGenerator,
+      BiFunction<TemporaryFolderExtension, Closer, List<Segment>> segmentGenerator,
       String vectorize
   )
   {
     BuiltInTypesModule.registerHandlersAndSerde();
     this.vectorize = QueryContexts.Vectorize.fromString(vectorize);
-    this.helper = AggregationTestHelper.createGroupByQueryAggregationTestHelper(
+    this.helper = AggregationTestHelper.createGroupByQueryAggregationTestHelperWithTemporaryFolderExtension(
         BuiltInTypesModule.getJacksonModulesList(),
         config,
         tempFolder
@@ -104,16 +106,14 @@ public class NestedDataGroupByQueryTest extends InitializedNullHandlingTest
         QueryContexts.VECTORIZE_VIRTUAL_COLUMNS_KEY, vectorize.toString()
     );
   }
-
-  @Parameterized.Parameters(name = "config = {0}, segments = {1}, vectorize = {2}")
   public static Collection<?> constructorFeeder()
   {
     final List<Object[]> constructors = new ArrayList<>();
-    final List<BiFunction<TemporaryFolder, Closer, List<Segment>>> segmentsGenerators =
-        NestedDataTestUtils.getSegmentGenerators(NestedDataTestUtils.SIMPLE_DATA_FILE);
+    final List<BiFunction<TemporaryFolderExtension, Closer, List<Segment>>> segmentsGenerators =
+        NestedDataTestUtils.getSegmentGeneratorsWithTempDir(NestedDataTestUtils.SIMPLE_DATA_FILE);
 
     for (GroupByQueryConfig config : GroupByQueryRunnerTest.testConfigs()) {
-      for (BiFunction<TemporaryFolder, Closer, List<Segment>> generatorFn : segmentsGenerators) {
+      for (BiFunction<TemporaryFolderExtension, Closer, List<Segment>> generatorFn : segmentsGenerators) {
         for (String vectorize : new String[]{"false", "true", "force"}) {
           constructors.add(new Object[]{config, generatorFn, vectorize});
         }
@@ -122,7 +122,7 @@ public class NestedDataGroupByQueryTest extends InitializedNullHandlingTest
     return constructors;
   }
 
-  @After
+  @AfterEach
   public void teardown() throws IOException
   {
     closer.close();
@@ -811,8 +811,8 @@ public class NestedDataGroupByQueryTest extends InitializedNullHandlingTest
 
     if (!allCanVectorize) {
       if (vectorize == QueryContexts.Vectorize.FORCE) {
-        Throwable t = Assert.assertThrows(RuntimeException.class, runner::get);
-        Assert.assertEquals(
+        Throwable t = Assertions.assertThrows(RuntimeException.class, runner::get);
+        Assertions.assertEquals(
             "java.util.concurrent.ExecutionException: java.lang.RuntimeException: org.apache.druid.java.util.common.ISE: Cannot vectorize!",
             t.getMessage()
         );
@@ -831,17 +831,17 @@ public class NestedDataGroupByQueryTest extends InitializedNullHandlingTest
   private static void verifyResults(RowSignature rowSignature, List<ResultRow> results, List<Object[]> expected)
   {
     LOG.info("results:\n%s", results);
-    Assert.assertEquals(expected.size(), results.size());
+    Assertions.assertEquals(expected.size(), results.size());
     for (int i = 0; i < expected.size(); i++) {
       final Object[] resultRow = results.get(i).getArray();
-      Assert.assertEquals(expected.get(i).length, resultRow.length);
+      Assertions.assertEquals(expected.get(i).length, resultRow.length);
       for (int j = 0; j < resultRow.length; j++) {
         if (rowSignature.getColumnType(j).map(t -> t.is(ValueType.DOUBLE)).orElse(false)) {
-          Assert.assertEquals((Double) expected.get(i)[j], (Double) resultRow[j], 0.01);
+          Assertions.assertEquals((Double) expected.get(i)[j], (Double) resultRow[j], 0.01);
         } else if (rowSignature.getColumnType(j).map(t -> t.is(ValueType.FLOAT)).orElse(false)) {
-          Assert.assertEquals((Float) expected.get(i)[j], (Float) resultRow[j], 0.01);
+          Assertions.assertEquals((Float) expected.get(i)[j], (Float) resultRow[j], 0.01);
         } else {
-          Assert.assertEquals(expected.get(i)[j], resultRow[j]);
+          Assertions.assertEquals(expected.get(i)[j], resultRow[j]);
         }
       }
     }
diff --git a/processing/src/test/java/org/apache/druid/query/groupby/NestedGroupByArrayQueryTest.java b/processing/src/test/java/org/apache/druid/query/groupby/NestedGroupByArrayQueryTest.java
index b39b850c9a3..1b102e3d262 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/NestedGroupByArrayQueryTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/NestedGroupByArrayQueryTest.java
@@ -39,14 +39,14 @@ import org.apache.druid.segment.column.ColumnType;
 import org.apache.druid.segment.column.RowSignature;
 import org.apache.druid.segment.column.ValueType;
 import org.apache.druid.segment.virtual.NestedFieldVirtualColumn;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+import org.apache.druid.testing.TemporaryFolderExtension;
+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.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -57,28 +57,30 @@ import java.util.function.BiFunction;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
-@RunWith(Parameterized.class)
+@ParameterizedClass
+
+@MethodSource("constructorFeeder")
 public class NestedGroupByArrayQueryTest
 {
   private static final Logger LOG = new Logger(NestedDataGroupByQueryTest.class);
 
-  @Rule
-  public final TemporaryFolder tempFolder = new TemporaryFolder();
+  @RegisterExtension
+  public final TemporaryFolderExtension tempFolder = new TemporaryFolderExtension();
 
   private final Closer closer;
   private final QueryContexts.Vectorize vectorize;
   private final AggregationTestHelper helper;
-  private final BiFunction<TemporaryFolder, Closer, List<Segment>> segmentsGenerator;
+  private final BiFunction<TemporaryFolderExtension, Closer, List<Segment>> segmentsGenerator;
 
   public NestedGroupByArrayQueryTest(
       GroupByQueryConfig config,
-      BiFunction<TemporaryFolder, Closer, List<Segment>> segmentGenerator,
+      BiFunction<TemporaryFolderExtension, Closer, List<Segment>> segmentGenerator,
       String vectorize
   )
   {
     BuiltInTypesModule.registerHandlersAndSerde();
     this.vectorize = QueryContexts.Vectorize.fromString(vectorize);
-    this.helper = AggregationTestHelper.createGroupByQueryAggregationTestHelper(
+    this.helper = AggregationTestHelper.createGroupByQueryAggregationTestHelperWithTemporaryFolderExtension(
         BuiltInTypesModule.getJacksonModulesList(),
         config,
         tempFolder
@@ -94,16 +96,14 @@ public class NestedGroupByArrayQueryTest
         QueryContexts.VECTORIZE_VIRTUAL_COLUMNS_KEY, vectorize.toString()
     );
   }
-
-  @Parameterized.Parameters(name = "config = {0}, segments = {1}, vectorize = {2}")
   public static Collection<?> constructorFeeder()
   {
     final List<Object[]> constructors = new ArrayList<>();
-    final List<BiFunction<TemporaryFolder, Closer, List<Segment>>> segmentsGenerators =
-        NestedDataTestUtils.getSegmentGenerators(NestedDataTestUtils.ARRAY_TYPES_DATA_FILE);
+    final List<BiFunction<TemporaryFolderExtension, Closer, List<Segment>>> segmentsGenerators =
+        NestedDataTestUtils.getSegmentGeneratorsWithTempDir(NestedDataTestUtils.ARRAY_TYPES_DATA_FILE);
 
     for (GroupByQueryConfig config : GroupByQueryRunnerTest.testConfigs()) {
-      for (BiFunction<TemporaryFolder, Closer, List<Segment>> generatorFn : segmentsGenerators) {
+      for (BiFunction<TemporaryFolderExtension, Closer, List<Segment>> generatorFn : segmentsGenerators) {
         // skip force because arrays don't really support vectorize engine, but we want the coverage for once they do...
         for (String vectorize : new String[]{"false", "true"}) {
           constructors.add(new Object[]{config, generatorFn, vectorize});
@@ -113,12 +113,12 @@ public class NestedGroupByArrayQueryTest
     return constructors;
   }
 
-  @Before
+  @BeforeEach
   public void setup()
   {
   }
 
-  @After
+  @AfterEach
   public void teardown() throws IOException
   {
     closer.close();
@@ -557,21 +557,21 @@ public class NestedGroupByArrayQueryTest
                )
                .collect(Collectors.toList());
     LOG.info("results:\n%s", serdeAndBack.stream().map(ResultRow::toString).collect(Collectors.joining("\n")));
-    Assert.assertEquals(expected.size(), serdeAndBack.size());
+    Assertions.assertEquals(expected.size(), serdeAndBack.size());
     for (int i = 0; i < expected.size(); i++) {
       final Object[] resultRow = serdeAndBack.get(i).getArray();
-      Assert.assertEquals(expected.get(i).length, resultRow.length);
+      Assertions.assertEquals(expected.get(i).length, resultRow.length);
       for (int j = 0; j < resultRow.length; j++) {
         if (expected.get(i)[j] == null) {
-          Assert.assertNull(resultRow[j]);
+          Assertions.assertNull(resultRow[j]);
         } else if (rowSignature.getColumnType(j).map(t -> t.is(ValueType.DOUBLE)).orElse(false)) {
-          Assert.assertEquals((Double) expected.get(i)[j], (Double) resultRow[j], 0.01);
+          Assertions.assertEquals((Double) expected.get(i)[j], (Double) resultRow[j], 0.01);
         } else if (rowSignature.getColumnType(j).map(t -> t.is(ValueType.FLOAT)).orElse(false)) {
-          Assert.assertEquals((Float) expected.get(i)[j], (Float) resultRow[j], 0.01);
+          Assertions.assertEquals((Float) expected.get(i)[j], (Float) resultRow[j], 0.01);
         } else if (rowSignature.getColumnType(j).map(t -> t.isArray()).orElse(false)) {
-          Assert.assertArrayEquals((Object[]) expected.get(i)[j], (Object[]) resultRow[j]);
+          Assertions.assertArrayEquals((Object[]) expected.get(i)[j], (Object[]) resultRow[j]);
         } else {
-          Assert.assertEquals(expected.get(i)[j], resultRow[j]);
+          Assertions.assertEquals(expected.get(i)[j], resultRow[j]);
         }
       }
     }
diff --git a/processing/src/test/java/org/apache/druid/query/groupby/NestedQueryPushDownTest.java b/processing/src/test/java/org/apache/druid/query/groupby/NestedQueryPushDownTest.java
index 5b89ca1c141..b2ad1e421ce 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/NestedQueryPushDownTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/NestedQueryPushDownTest.java
@@ -78,10 +78,10 @@ import org.apache.druid.segment.incremental.OnheapIncrementalIndex;
 import org.apache.druid.segment.writeout.OffHeapMemorySegmentWriteOutMediumFactory;
 import org.apache.druid.testing.InitializedNullHandlingTest;
 import org.apache.druid.timeline.SegmentId;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+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 java.io.File;
 import java.util.ArrayList;
@@ -137,7 +137,7 @@ public class NestedQueryPushDownTest extends InitializedNullHandlingTest
         .build();
   }
 
-  @Before
+  @BeforeEach
   public void setup() throws Exception
   {
     closer = Closer.create();
@@ -248,9 +248,9 @@ public class NestedQueryPushDownTest extends InitializedNullHandlingTest
     TestBufferPool mergePool2 = TestBufferPool.offHeap(10_000_000, 10);
     closer.register(() -> {
       // Verify that all objects have been returned to the pool.
-      Assert.assertEquals(0, bufferPool.getOutstandingObjectCount());
-      Assert.assertEquals(0, mergePool.getOutstandingObjectCount());
-      Assert.assertEquals(0, mergePool2.getOutstandingObjectCount());
+      Assertions.assertEquals(0, bufferPool.getOutstandingObjectCount());
+      Assertions.assertEquals(0, mergePool.getOutstandingObjectCount());
+      Assertions.assertEquals(0, mergePool2.getOutstandingObjectCount());
     });
 
     final GroupByQueryConfig config = new GroupByQueryConfig()
@@ -324,7 +324,7 @@ public class NestedQueryPushDownTest extends InitializedNullHandlingTest
     );
   }
 
-  @After
+  @AfterEach
   public void tearDown() throws Exception
   {
     closer.close();
@@ -393,9 +393,9 @@ public class NestedQueryPushDownTest extends InitializedNullHandlingTest
         "totalSum", 6000L
     );
 
-    Assert.assertEquals(2, results.size());
-    Assert.assertEquals(expectedRow0, results.get(0));
-    Assert.assertEquals(expectedRow1, results.get(1));
+    Assertions.assertEquals(2, results.size());
+    Assertions.assertEquals(expectedRow0, results.get(0));
+    Assertions.assertEquals(expectedRow1, results.get(1));
   }
 
   @Test
@@ -447,9 +447,9 @@ public class NestedQueryPushDownTest extends InitializedNullHandlingTest
         "renamedDimB", "sweet",
         "maxBSum", 60L
     );
-    Assert.assertEquals(2, results.size());
-    Assert.assertEquals(expectedRow0, results.get(0));
-    Assert.assertEquals(expectedRow1, results.get(1));
+    Assertions.assertEquals(2, results.size());
+    Assertions.assertEquals(expectedRow0, results.get(0));
+    Assertions.assertEquals(expectedRow1, results.get(1));
   }
 
   @Test
@@ -499,7 +499,7 @@ public class NestedQueryPushDownTest extends InitializedNullHandlingTest
     Sequence<ResultRow> queryResult = runNestedQueryWithForcePushDown(nestedQuery);
     List<ResultRow> results = queryResult.toList();
 
-    Assert.assertEquals(0, results.size());
+    Assertions.assertEquals(0, results.size());
   }
 
   @Test
@@ -549,8 +549,8 @@ public class NestedQueryPushDownTest extends InitializedNullHandlingTest
     Sequence<ResultRow> queryResult = runNestedQueryWithForcePushDown(nestedQuery);
     List<ResultRow> results = queryResult.toList();
 
-    Assert.assertEquals(1, results.size());
-    Assert.assertEquals(expectedRow0, results.get(0));
+    Assertions.assertEquals(1, results.size());
+    Assertions.assertEquals(expectedRow0, results.get(0));
   }
 
   @Test
@@ -600,8 +600,8 @@ public class NestedQueryPushDownTest extends InitializedNullHandlingTest
     Sequence<ResultRow> queryResult = runNestedQueryWithForcePushDown(nestedQuery);
     List<ResultRow> results = queryResult.toList();
 
-    Assert.assertEquals(1, results.size());
-    Assert.assertEquals(expectedRow0, results.get(0));
+    Assertions.assertEquals(1, results.size());
+    Assertions.assertEquals(expectedRow0, results.get(0));
   }
 
   @Test
@@ -653,9 +653,9 @@ public class NestedQueryPushDownTest extends InitializedNullHandlingTest
     Sequence<ResultRow> queryResult = runNestedQueryWithForcePushDown(nestedQuery);
     List<ResultRow> results = queryResult.toList();
 
-    Assert.assertEquals(2, results.size());
-    Assert.assertEquals(expectedRow0, results.get(0));
-    Assert.assertEquals(expectedRow1, results.get(1));
+    Assertions.assertEquals(2, results.size());
+    Assertions.assertEquals(expectedRow0, results.get(0));
+    Assertions.assertEquals(expectedRow1, results.get(1));
   }
 
   @Test
@@ -700,8 +700,8 @@ public class NestedQueryPushDownTest extends InitializedNullHandlingTest
     Sequence<ResultRow> queryResult = runNestedQueryWithForcePushDown(nestedQuery);
     List<ResultRow> results = queryResult.toList();
 
-    Assert.assertEquals(1, results.size());
-    Assert.assertEquals(expectedRow0, results.get(0));
+    Assertions.assertEquals(1, results.size());
+    Assertions.assertEquals(expectedRow0, results.get(0));
   }
 
   private Sequence<ResultRow> runNestedQueryWithForcePushDown(GroupByQuery nestedQuery)
@@ -803,8 +803,8 @@ public class NestedQueryPushDownTest extends InitializedNullHandlingTest
         .build();
     QueryToolChest<ResultRow, GroupByQuery> toolChest = groupByFactory.getToolchest();
     GroupByQuery rewrittenQuery = ((GroupByQueryQueryToolChest) toolChest).rewriteNestedQueryForPushDown(nestedQuery);
-    Assert.assertEquals(outputNameB, rewrittenQuery.getDimensions().get(0).getDimension());
-    Assert.assertEquals(outputNameAgg, rewrittenQuery.getAggregatorSpecs().get(0).getName());
+    Assertions.assertEquals(outputNameB, rewrittenQuery.getDimensions().get(0).getDimension());
+    Assertions.assertEquals(outputNameAgg, rewrittenQuery.getAggregatorSpecs().get(0).getName());
   }
 
   public static <T, QueryType extends Query<T>> QueryRunner<T> makeQueryRunner(
diff --git a/processing/src/test/java/org/apache/druid/query/groupby/UnnestGroupByQueryRunnerTest.java b/processing/src/test/java/org/apache/druid/query/groupby/UnnestGroupByQueryRunnerTest.java
index b220f00b05a..875b60de36e 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/UnnestGroupByQueryRunnerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/UnnestGroupByQueryRunnerTest.java
@@ -58,15 +58,15 @@ import org.apache.druid.segment.incremental.IncrementalIndex;
 import org.apache.druid.segment.incremental.IncrementalIndexSchema;
 import org.apache.druid.segment.virtual.ExpressionVirtualColumn;
 import org.apache.druid.testing.InitializedNullHandlingTest;
+import org.apache.druid.testing.TemporaryFolderExtension;
 import org.joda.time.DateTime;
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.junit.rules.TemporaryFolder;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+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 org.junit.jupiter.api.extension.RegisterExtension;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -77,7 +77,10 @@ import java.util.List;
 import java.util.Map;
 
 
-@RunWith(Parameterized.class)
+@ParameterizedClass
+
+
+@MethodSource("constructorFeeder")
 public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
 {
   private static TestGroupByBuffers BUFFER_POOLS = null;
@@ -86,11 +89,8 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
   private final GroupByQueryConfig config;
   private final boolean vectorize;
 
-  @Rule
-  public ExpectedException expectedException = ExpectedException.none();
-
-  @Rule
-  public final TemporaryFolder tempFolder = new TemporaryFolder();
+  @RegisterExtension
+  public final TemporaryFolderExtension tempFolder = new TemporaryFolderExtension();
 
   public UnnestGroupByQueryRunnerTest(
       GroupByQueryConfig config,
@@ -188,8 +188,6 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
         new GroupByQueryQueryToolChest(groupingEngine, groupByResourcesReservationPool);
     return new GroupByQueryRunnerFactory(groupingEngine, toolChest, bufferPools.getProcessingPool());
   }
-
-  @Parameterized.Parameters(name = "{0}")
   public static Collection<Object[]> constructorFeeder()
   {
     setUpClass();
@@ -208,7 +206,7 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
     return constructors;
   }
 
-  @BeforeClass
+  @BeforeAll
   public static void setUpClass()
   {
     if (BUFFER_POOLS == null) {
@@ -216,7 +214,7 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
     }
   }
 
-  @AfterClass
+  @AfterAll
   public static void tearDownClass()
   {
     BUFFER_POOLS.close();
@@ -451,7 +449,6 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
   public void testGroupByOnMissingColumn()
   {
     // Cannot vectorize due to extraction dimension spec.
-    cannotVectorize();
 
     GroupByQuery query = makeQueryBuilder()
         .setDataSource(UnnestDataSource.create(
@@ -482,6 +479,14 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> runQuery(query, TestIndex.getIncrementalTestIndex())
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = runQuery(query, TestIndex.getIncrementalTestIndex());
     TestHelper.assertExpectedObjects(expectedResults, results, "missing-column");
 
@@ -492,7 +497,6 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
   @Test
   public void testGroupByOnUnnestedColumn()
   {
-    cannotVectorize();
 
     GroupByQuery query = makeQueryBuilder()
         .setDataSource(QueryRunnerTestHelper.UNNEST_DATA_SOURCE)
@@ -561,6 +565,14 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> runQuery(query, TestIndex.getIncrementalTestIndex())
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = runQuery(query, TestIndex.getIncrementalTestIndex());
     TestHelper.assertExpectedObjects(expectedResults, results, "groupBy-on-unnested-column");
 
@@ -571,7 +583,6 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
   @Test
   public void testGroupByOnUnnestedVirtualColumn()
   {
-    cannotVectorize();
 
     final DataSource unnestDataSource = UnnestDataSource.create(
         new TableDataSource(QueryRunnerTestHelper.DATA_SOURCE),
@@ -653,6 +664,14 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> runQuery(query, TestIndex.getIncrementalTestIndex())
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = runQuery(query, TestIndex.getIncrementalTestIndex());
     TestHelper.assertExpectedObjects(expectedResults, results, "groupBy-on-unnested-virtual-column");
 
@@ -663,7 +682,6 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
   @Test
   public void testGroupByOnUnnestedVirtualMultiColumn()
   {
-    cannotVectorize();
 
     final DataSource unnestDataSource = UnnestDataSource.create(
         new TableDataSource(QueryRunnerTestHelper.DATA_SOURCE),
@@ -707,6 +725,14 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> runQuery(query, TestIndex.getIncrementalTestIndex())
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = runQuery(query, TestIndex.getIncrementalTestIndex());
     TestHelper.assertExpectedObjects(expectedResults, results, "groupBy-on-unnested-virtual-columns");
 
@@ -717,7 +743,6 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
   @Test
   public void testGroupByOnUnnestedStringColumnWithNullStuff() throws IOException
   {
-    cannotVectorize();
 
     final String dim = "mvd";
     final DateTime timestamp = DateTimes.nowUtc();
@@ -768,6 +793,14 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
         makeRow(query, timestamp, "v0", "c", "rows", 1L)
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> runQuery(query, bob.buildIncrementalIndex())
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = runQuery(query, bob.buildIncrementalIndex());
     TestHelper.assertExpectedObjects(expectedResults, results, "group-by-unnested-string-nulls");
 
@@ -778,7 +811,6 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
   @Test
   public void testGroupByOnUnnestedStringColumnWithMoreNullStuff() throws IOException
   {
-    cannotVectorize();
 
     final String dim = "mvd";
     final DateTime timestamp = DateTimes.nowUtc();
@@ -841,6 +873,14 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
         makeRow(query, timestamp, "v0", "c", "rows", 1L)
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> runQuery(query, bob.buildIncrementalIndex())
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = runQuery(query, bob.buildIncrementalIndex());
     TestHelper.assertExpectedObjects(expectedResults, results, "group-by-unnested-string-nulls");
 
@@ -854,7 +894,6 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
   @Test
   public void testGroupByOnUnnestEmptyTable()
   {
-    cannotVectorize();
     IndexBuilder bob =
         IndexBuilder.create()
                     .rows(ImmutableList.of());
@@ -880,6 +919,14 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
 
     List<ResultRow> expectedResults = Collections.emptyList();
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> runQuery(query, bob.buildIncrementalIndex())
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = runQuery(query, bob.buildIncrementalIndex());
     TestHelper.assertExpectedObjects(expectedResults, results, "group-by-unnested-empty");
 
@@ -889,7 +936,6 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
   @Test
   public void testGroupByOnUnnestEmptyRows()
   {
-    cannotVectorize();
     final String dim = "mvd";
     final DateTime timestamp = DateTimes.nowUtc();
     final RowSignature signature = RowSignature.builder()
@@ -941,6 +987,14 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
         makeRow(query, timestamp, "v0", null, "rows", 1L)
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> runQuery(query, bob.buildIncrementalIndex())
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = runQuery(query, bob.buildIncrementalIndex());
     TestHelper.assertExpectedObjects(expectedResults, results, "group-by-unnested-empty");
 
@@ -957,7 +1011,6 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
     // the issue is that the dimension selector handles null differently than if arrays are used from a column value
     // selector. the dimension selector cursor puts nulls in the output to be compatible with implict unnest used by
     // group-by, while the column selector cursor uses array rules
-    cannotVectorize();
 
     final String dim = "mvd";
     final DateTime timestamp = DateTimes.nowUtc();
@@ -1018,6 +1071,14 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
         makeRow(query, timestamp, "v1", "c", "rows", 1L)
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> runQuery(query, bob.buildIncrementalIndex())
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = runQuery(query, bob.buildIncrementalIndex());
     TestHelper.assertExpectedObjects(expectedResults, results, "group-by-unnested-string-nulls-double-unnest");
 
@@ -1029,7 +1090,6 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
   public void testGroupByOnUnnestedFilterMatch()
   {
     // testGroupByOnUnnestedColumn but with filter to match single value
-    cannotVectorize();
 
     final DataSource unnestDataSource = UnnestDataSource.create(
         new TableDataSource(QueryRunnerTestHelper.DATA_SOURCE),
@@ -1065,6 +1125,14 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> runQuery(query, TestIndex.getIncrementalTestIndex())
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = runQuery(query, TestIndex.getIncrementalTestIndex());
     TestHelper.assertExpectedObjects(expectedResults, results, "groupBy-on-unnested-virtual-column");
 
@@ -1076,7 +1144,6 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
   public void testGroupByOnUnnestedNotFilterMatch()
   {
     // testGroupByOnUnnestedColumn but with negated filter to match everything except 1 value
-    cannotVectorize();
 
     final DataSource unnestDataSource = UnnestDataSource.create(
         new TableDataSource(QueryRunnerTestHelper.DATA_SOURCE),
@@ -1154,6 +1221,14 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> runQuery(query, TestIndex.getIncrementalTestIndex())
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = runQuery(query, TestIndex.getIncrementalTestIndex());
     TestHelper.assertExpectedObjects(expectedResults, results, "groupBy-on-unnested-virtual-column");
 
@@ -1165,7 +1240,6 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
   public void testGroupByOnUnnestedNotFilterMatchNonexistentValue()
   {
     // testGroupByOnUnnestedColumn but with negated filter on nonexistent value to still match everything
-    cannotVectorize();
 
     final DataSource unnestDataSource = UnnestDataSource.create(
         new TableDataSource(QueryRunnerTestHelper.DATA_SOURCE),
@@ -1249,6 +1323,14 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
         )
     );
 
+    if (vectorize) {
+      final RuntimeException exception = Assertions.assertThrows(
+          RuntimeException.class,
+          () -> runQuery(query, TestIndex.getIncrementalTestIndex())
+      );
+      Assertions.assertTrue(exception.getMessage().contains("Cannot vectorize!"));
+      return;
+    }
     Iterable<ResultRow> results = runQuery(query, TestIndex.getIncrementalTestIndex());
     TestHelper.assertExpectedObjects(expectedResults, results, "groupBy-on-unnested-virtual-column");
   }
@@ -1312,11 +1394,4 @@ public class UnnestGroupByQueryRunnerTest extends InitializedNullHandlingTest
                        .build();
   }
 
-  private void cannotVectorize()
-  {
-    if (vectorize) {
-      expectedException.expect(RuntimeException.class);
-      expectedException.expectMessage("Cannot vectorize!");
-    }
-  }
 }
diff --git a/processing/src/test/java/org/apache/druid/query/groupby/epinephelinae/ConcurrentGrouperTest.java b/processing/src/test/java/org/apache/druid/query/groupby/epinephelinae/ConcurrentGrouperTest.java
index 0b793f429b4..e7e8ec08db4 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/epinephelinae/ConcurrentGrouperTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/epinephelinae/ConcurrentGrouperTest.java
@@ -46,15 +46,14 @@ import org.apache.druid.segment.ColumnValueSelector;
 import org.apache.druid.segment.DimensionSelector;
 import org.apache.druid.segment.column.ColumnCapabilities;
 import org.apache.druid.testing.InitializedNullHandlingTest;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
+import org.apache.druid.testing.TemporaryFolderExtension;
+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.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import java.io.IOException;
 import java.nio.ByteBuffer;
@@ -67,15 +66,17 @@ import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;
 import java.util.concurrent.atomic.AtomicBoolean;
 
-@RunWith(Parameterized.class)
+@ParameterizedClass
+
+@MethodSource("constructorFeeder")
 public class ConcurrentGrouperTest extends InitializedNullHandlingTest
 {
   private static final TestResourceHolder TEST_RESOURCE_HOLDER = new TestResourceHolder(256);
   private static final KeySerdeFactory<LongKey> KEY_SERDE_FACTORY = new TestKeySerdeFactory();
   private static final ColumnSelectorFactory NULL_FACTORY = new TestColumnSelectorFactory();
 
-  @Rule
-  public TemporaryFolder temporaryFolder = new TemporaryFolder();
+  @RegisterExtension
+  public TemporaryFolderExtension temporaryFolder = new TemporaryFolderExtension();
 
   private final Supplier<ByteBuffer> bufferSupplier;
   private final int concurrencyHint;
@@ -84,7 +85,6 @@ public class ConcurrentGrouperTest extends InitializedNullHandlingTest
   private final boolean mergeThreadLocal;
   private final Closer closer = Closer.create();
 
-  @Parameters(name = "bufferSize={0}, concurrencyHint={1}, parallelCombineThreads={2}, mergeThreadLocal={3}")
   public static Collection<Object[]> constructorFeeder()
   {
     final List<Object[]> constructors = new ArrayList<>();
@@ -104,13 +104,13 @@ public class ConcurrentGrouperTest extends InitializedNullHandlingTest
     return constructors;
   }
 
-  @Before
+  @BeforeEach
   public void setUp()
   {
     TEST_RESOURCE_HOLDER.taken = false;
   }
 
-  @After
+  @AfterEach
   public void tearDown() throws IOException
   {
     exec.shutdownNow();
@@ -213,9 +213,9 @@ public class ConcurrentGrouperTest extends InitializedNullHandlingTest
       if (parallelCombineThreads > 1 && (mergeThreadLocal || temporaryStorage.currentSize() > 0)) {
         // Parallel combiner configured, and expected to actually be used due to thread-local merge (either explicitly
         // configured, or due to spilling).
-        Assert.assertTrue(TEST_RESOURCE_HOLDER.taken);
+        Assertions.assertTrue(TEST_RESOURCE_HOLDER.taken);
       } else {
-        Assert.assertFalse(TEST_RESOURCE_HOLDER.taken);
+        Assertions.assertFalse(TEST_RESOURCE_HOLDER.taken);
       }
 
       GrouperTestUtil.assertEntriesEquals(expected.iterator(), iterator);
@@ -282,12 +282,12 @@ public class ConcurrentGrouperTest extends InitializedNullHandlingTest
         eachFuture.get();
       }
 
-      final QueryTimeoutException e = Assert.assertThrows(
+      final QueryTimeoutException e = Assertions.assertThrows(
           QueryTimeoutException.class,
           () -> closer.register(grouper.iterator(true))
       );
 
-      Assert.assertEquals("Query timeout", e.getErrorCode());
+      Assertions.assertEquals("Query timeout", e.getErrorCode());
     }
     finally {
       service.shutdownNow();
diff --git a/processing/src/test/java/org/apache/druid/query/groupby/epinephelinae/LimitedBufferHashGrouperTest.java b/processing/src/test/java/org/apache/druid/query/groupby/epinephelinae/LimitedBufferHashGrouperTest.java
index df9851ba829..0833a8ee490 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/epinephelinae/LimitedBufferHashGrouperTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/epinephelinae/LimitedBufferHashGrouperTest.java
@@ -37,10 +37,8 @@ import org.apache.druid.query.groupby.orderby.OrderByColumnSpec;
 import org.apache.druid.query.ordering.StringComparator;
 import org.apache.druid.query.ordering.StringComparators;
 import org.apache.druid.testing.InitializedNullHandlingTest;
-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.Test;
 
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
@@ -54,9 +52,6 @@ public class LimitedBufferHashGrouperTest extends InitializedNullHandlingTest
   static final int KEY_BASE = 100000;
   static final int NUM_ROWS = 1000;
 
-  @Rule
-  public ExpectedException expectedException = ExpectedException.none();
-
   @Test
   public void testLimitAndBufferSwapping()
   {
@@ -65,7 +60,7 @@ public class LimitedBufferHashGrouperTest extends InitializedNullHandlingTest
 
     columnSelectorFactory.setRow(new MapBasedRow(0, ImmutableMap.of("value", 10L)));
     for (int i = 0; i < NUM_ROWS; i++) {
-      Assert.assertTrue(String.valueOf(i + KEY_BASE), grouper.aggregate(new IntKey(i + KEY_BASE)).isOk());
+      Assertions.assertTrue(grouper.aggregate(new IntKey(i + KEY_BASE)).isOk(), String.valueOf(i + KEY_BASE));
     }
     // With Nullability enabled
     // bucket size is hash(int) + key(int) + aggs(2 longs + 1 bytes for Long Agg nullability) + heap offset(int) = 29 bytes
@@ -77,19 +72,19 @@ public class LimitedBufferHashGrouperTest extends InitializedNullHandlingTest
     // Subsequent buffer swaps occur after every 68 buckets, since we keep 100 buckets due to the limit
     // With 1000 keys inserted, this results in one swap at the first 169 buckets, then 12 swaps afterwards.
     // After the last swap, we have 100 keys + 16 new keys inserted.
-    Assert.assertEquals(13, grouper.getGrowthCount());
-    Assert.assertEquals(116, grouper.getSize());
-    Assert.assertEquals(337, grouper.getBuckets());
-    Assert.assertEquals(168, grouper.getMaxSize());
+    Assertions.assertEquals(13, grouper.getGrowthCount());
+    Assertions.assertEquals(116, grouper.getSize());
+    Assertions.assertEquals(337, grouper.getBuckets());
+    Assertions.assertEquals(168, grouper.getMaxSize());
 
-    Assert.assertEquals(100, grouper.getLimit());
+    Assertions.assertEquals(100, grouper.getLimit());
 
     // Aggregate slightly different row
     // Since these keys are smaller, they will evict the previous 100 top entries
     // First 100 of these new rows will be the expected results.
     columnSelectorFactory.setRow(new MapBasedRow(0, ImmutableMap.of("value", 11L)));
     for (int i = 0; i < NUM_ROWS; i++) {
-      Assert.assertTrue(String.valueOf(i), grouper.aggregate(new IntKey(i)).isOk());
+      Assertions.assertTrue(grouper.aggregate(new IntKey(i)).isOk(), String.valueOf(i));
     }
 
     // With Nullable Aggregator
@@ -97,30 +92,34 @@ public class LimitedBufferHashGrouperTest extends InitializedNullHandlingTest
     // previous size is 116, so next swap occurs after 52 rows
     // after that, there are 1000 - 52 = 948 rows, 948 / 68 = 13 additional swaps after the first,
     // with 64 keys being added after the final swap.
-    Assert.assertEquals(27, grouper.getGrowthCount());
-    Assert.assertEquals(164, grouper.getSize());
-    Assert.assertEquals(337, grouper.getBuckets());
-    Assert.assertEquals(168, grouper.getMaxSize());
+    Assertions.assertEquals(27, grouper.getGrowthCount());
+    Assertions.assertEquals(164, grouper.getSize());
+    Assertions.assertEquals(337, grouper.getBuckets());
+    Assertions.assertEquals(168, grouper.getMaxSize());
 
-    Assert.assertEquals(100, grouper.getLimit());
+    Assertions.assertEquals(100, grouper.getLimit());
 
     final List<Pair<Integer, List<Object>>> expected = new ArrayList<>();
     for (int i = 0; i < LIMIT; i++) {
       expected.add(Pair.of(i, ImmutableList.of(11L, 1L)));
     }
 
-    Assert.assertEquals(expected, entriesToList(grouper.iterator(true)));
+    Assertions.assertEquals(expected, entriesToList(grouper.iterator(true)));
     // iterate again, even though the min-max offset heap has been destroyed, it is replaced with a reverse sorted array
-    Assert.assertEquals(expected, entriesToList(grouper.iterator(true)));
+    Assertions.assertEquals(expected, entriesToList(grouper.iterator(true)));
   }
 
   @Test
   public void testBufferTooSmall()
   {
-    expectedException.expect(IAE.class);
-    expectedException.expectMessage("LimitedBufferHashGrouper initialized with insufficient buffer capacity");
     final GroupByTestColumnSelectorFactory columnSelectorFactory = GrouperTestUtil.newColumnSelectorFactory();
-    makeGrouper(columnSelectorFactory, 10);
+    final IAE exception = Assertions.assertThrows(
+        IAE.class,
+        () -> makeGrouper(columnSelectorFactory, 10)
+    );
+    Assertions.assertTrue(
+        exception.getMessage().contains("LimitedBufferHashGrouper initialized with insufficient buffer capacity")
+    );
   }
 
   @Test
@@ -131,57 +130,65 @@ public class LimitedBufferHashGrouperTest extends InitializedNullHandlingTest
 
     columnSelectorFactory.setRow(new MapBasedRow(0, ImmutableMap.of("value", 10L)));
     for (int i = 0; i < NUM_ROWS; i++) {
-      Assert.assertTrue(String.valueOf(i + KEY_BASE), grouper.aggregate(new IntKey(i + KEY_BASE)).isOk());
+      Assertions.assertTrue(grouper.aggregate(new IntKey(i + KEY_BASE)).isOk(), String.valueOf(i + KEY_BASE));
     }
 
     // With minimum buffer size, after the first swap, every new key added will result in a swap
-    Assert.assertEquals(899, grouper.getGrowthCount());
-    Assert.assertEquals(101, grouper.getSize());
-    Assert.assertEquals(202, grouper.getBuckets());
-    Assert.assertEquals(101, grouper.getMaxSize());
-    Assert.assertEquals(100, grouper.getLimit());
+    Assertions.assertEquals(899, grouper.getGrowthCount());
+    Assertions.assertEquals(101, grouper.getSize());
+    Assertions.assertEquals(202, grouper.getBuckets());
+    Assertions.assertEquals(101, grouper.getMaxSize());
+    Assertions.assertEquals(100, grouper.getLimit());
 
     // Aggregate slightly different row
     // Since these keys are smaller, they will evict the previous 100 top entries
     // First 100 of these new rows will be the expected results.
     columnSelectorFactory.setRow(new MapBasedRow(0, ImmutableMap.of("value", 11L)));
     for (int i = 0; i < NUM_ROWS; i++) {
-      Assert.assertTrue(String.valueOf(i), grouper.aggregate(new IntKey(i)).isOk());
+      Assertions.assertTrue(grouper.aggregate(new IntKey(i)).isOk(), String.valueOf(i));
     }
-    Assert.assertEquals(1899, grouper.getGrowthCount());
-    Assert.assertEquals(101, grouper.getSize());
-    Assert.assertEquals(202, grouper.getBuckets());
-    Assert.assertEquals(101, grouper.getMaxSize());
-    Assert.assertEquals(100, grouper.getLimit());
+    Assertions.assertEquals(1899, grouper.getGrowthCount());
+    Assertions.assertEquals(101, grouper.getSize());
+    Assertions.assertEquals(202, grouper.getBuckets());
+    Assertions.assertEquals(101, grouper.getMaxSize());
+    Assertions.assertEquals(100, grouper.getLimit());
 
     final List<Pair<Integer, List<Object>>> expected = new ArrayList<>();
     for (int i = 0; i < LIMIT; i++) {
       expected.add(Pair.of(i, ImmutableList.of(11L, 1L)));
     }
 
-    Assert.assertEquals(expected, entriesToList(grouper.iterator(true)));
+    Assertions.assertEquals(expected, entriesToList(grouper.iterator(true)));
     // iterate again, even though the min-max offset heap has been destroyed, it is replaced with a reverse sorted array
-    Assert.assertEquals(expected, entriesToList(grouper.iterator(true)));
+    Assertions.assertEquals(expected, entriesToList(grouper.iterator(true)));
   }
 
   @Test
   public void testAggregateAfterIterated()
   {
-    expectedException.expect(IllegalStateException.class);
-    expectedException.expectMessage("attempted to add offset after grouper was iterated");
-
-    final GroupByTestColumnSelectorFactory columnSelectorFactory = GrouperTestUtil.newColumnSelectorFactory();
-    final LimitedBufferHashGrouper<IntKey> grouper = makeGrouper(columnSelectorFactory, 12120);
-
-    columnSelectorFactory.setRow(new MapBasedRow(0, ImmutableMap.of("value", 10L)));
-    for (int i = 0; i < NUM_ROWS; i++) {
-      Assert.assertTrue(String.valueOf(i + KEY_BASE), grouper.aggregate(new IntKey(i + KEY_BASE)).isOk());
-    }
-    List<Grouper.Entry<IntKey>> iterated = Lists.newArrayList(grouper.iterator(true));
-    Assert.assertEquals(LIMIT, iterated.size());
-
-    // an attempt to aggregate with a new key will explode after the grouper has been iterated
-    grouper.aggregate(new IntKey(KEY_BASE + NUM_ROWS + 1));
+    final IllegalStateException exception = Assertions.assertThrows(
+        IllegalStateException.class,
+        () -> {
+          final GroupByTestColumnSelectorFactory columnSelectorFactory = GrouperTestUtil.newColumnSelectorFactory();
+          final LimitedBufferHashGrouper<IntKey> grouper = makeGrouper(columnSelectorFactory, 12120);
+
+          columnSelectorFactory.setRow(new MapBasedRow(0, ImmutableMap.of("value", 10L)));
+          for (int i = 0; i < NUM_ROWS; i++) {
+            Assertions.assertTrue(
+                grouper.aggregate(new IntKey(i + KEY_BASE)).isOk(),
+                String.valueOf(i + KEY_BASE)
+            );
+          }
+          final List<Grouper.Entry<IntKey>> iterated = Lists.newArrayList(grouper.iterator(true));
+          Assertions.assertEquals(LIMIT, iterated.size());
+
+          // an attempt to aggregate with a new key will explode after the grouper has been iterated
+          grouper.aggregate(new IntKey(KEY_BASE + NUM_ROWS + 1));
+        }
+    );
+    Assertions.assertTrue(
+        exception.getMessage().contains("attempted to add offset after grouper was iterated")
+    );
   }
 
   @Test
@@ -198,9 +205,9 @@ public class LimitedBufferHashGrouperTest extends InitializedNullHandlingTest
       // limited grouper iterator will always sort by keys in ascending order, even if the heap was sorted by values
       // so, we aggregate with keys and values both descending so that the results are not re-ordered by key
       columnSelectorFactory.setRow(new MapBasedRow(0, ImmutableMap.of("value", NUM_ROWS - i + KEY_BASE)));
-      Assert.assertTrue(
-          String.valueOf(NUM_ROWS - i + KEY_BASE),
-          grouper.aggregate(new IntKey(NUM_ROWS - i + KEY_BASE)).isOk()
+      Assertions.assertTrue(
+          grouper.aggregate(new IntKey(NUM_ROWS - i + KEY_BASE)).isOk(),
+          String.valueOf(NUM_ROWS - i + KEY_BASE)
       );
     }
 
@@ -209,11 +216,11 @@ public class LimitedBufferHashGrouperTest extends InitializedNullHandlingTest
     int i = 0;
     while (iterator.hasNext()) {
       final Grouper.Entry<IntKey> entry = iterator.next();
-      Assert.assertEquals(KEY_BASE + i + 1L, entry.getValues()[0]);
+      Assertions.assertEquals(KEY_BASE + i + 1L, entry.getValues()[0]);
       i++;
     }
 
-    Assert.assertEquals(LIMIT, i);
+    Assertions.assertEquals(LIMIT, i);
   }
 
   @Test
@@ -230,7 +237,7 @@ public class LimitedBufferHashGrouperTest extends InitializedNullHandlingTest
       // limited grouper iterator will always sort by keys in ascending order, even if the heap was sorted by values
       // so, we aggregate with keys and values both ascending so that the results are not re-ordered by key
       columnSelectorFactory.setRow(new MapBasedRow(0, ImmutableMap.of("value", i + 1)));
-      Assert.assertTrue(String.valueOf(i + KEY_BASE), grouper.aggregate(new IntKey(i + KEY_BASE)).isOk());
+      Assertions.assertTrue(grouper.aggregate(new IntKey(i + KEY_BASE)).isOk(), String.valueOf(i + KEY_BASE));
     }
 
     final CloseableIterator<Grouper.Entry<IntKey>> iterator = grouper.iterator(true);
@@ -238,7 +245,7 @@ public class LimitedBufferHashGrouperTest extends InitializedNullHandlingTest
     int i = 0;
     while (iterator.hasNext()) {
       final Grouper.Entry<IntKey> entry = iterator.next();
-      Assert.assertEquals((long) NUM_ROWS - i, entry.getValues()[0]);
+      Assertions.assertEquals((long) NUM_ROWS - i, entry.getValues()[0]);
       i++;
     }
   }
@@ -257,9 +264,9 @@ public class LimitedBufferHashGrouperTest extends InitializedNullHandlingTest
       // limited grouper iterator will always sort by keys in ascending order, even if the heap was sorted by values
       // so, we aggregate with keys and values both descending so that the results are not re-ordered by key
       columnSelectorFactory.setRow(new MapBasedRow(0, ImmutableMap.of("value", NUM_ROWS - i)));
-      Assert.assertTrue(
-          String.valueOf(NUM_ROWS - i + KEY_BASE),
-          grouper.aggregate(new IntKey(NUM_ROWS - i + KEY_BASE)).isOk()
+      Assertions.assertTrue(
+          grouper.aggregate(new IntKey(NUM_ROWS - i + KEY_BASE)).isOk(),
+          String.valueOf(NUM_ROWS - i + KEY_BASE)
       );
     }
 
@@ -268,11 +275,11 @@ public class LimitedBufferHashGrouperTest extends InitializedNullHandlingTest
     int i = 0;
     while (iterator.hasNext()) {
       final Grouper.Entry<IntKey> entry = iterator.next();
-      Assert.assertEquals(i + 1L, entry.getValues()[0]);
+      Assertions.assertEquals(i + 1L, entry.getValues()[0]);
       i++;
     }
 
-    Assert.assertEquals(LIMIT, i);
+    Assertions.assertEquals(LIMIT, i);
   }
 
   @Test
@@ -289,9 +296,9 @@ public class LimitedBufferHashGrouperTest extends InitializedNullHandlingTest
       // limited grouper iterator will always sort by keys in ascending order, even if the heap was sorted by values
       // so, we aggregate with keys descending and values asending so that the results are not re-ordered by key
       columnSelectorFactory.setRow(new MapBasedRow(0, ImmutableMap.of("value", i + 1)));
-      Assert.assertTrue(
-          String.valueOf(NUM_ROWS - i + KEY_BASE),
-          grouper.aggregate(new IntKey(NUM_ROWS - i + KEY_BASE)).isOk()
+      Assertions.assertTrue(
+          grouper.aggregate(new IntKey(NUM_ROWS - i + KEY_BASE)).isOk(),
+          String.valueOf(NUM_ROWS - i + KEY_BASE)
       );
     }
 
@@ -300,11 +307,11 @@ public class LimitedBufferHashGrouperTest extends InitializedNullHandlingTest
     int i = 0;
     while (iterator.hasNext()) {
       final Grouper.Entry<IntKey> entry = iterator.next();
-      Assert.assertEquals((long) NUM_ROWS - i, entry.getValues()[0]);
+      Assertions.assertEquals((long) NUM_ROWS - i, entry.getValues()[0]);
       i++;
     }
 
-    Assert.assertEquals(LIMIT, i);
+    Assertions.assertEquals(LIMIT, i);
   }
 
   @Test
@@ -313,22 +320,22 @@ public class LimitedBufferHashGrouperTest extends InitializedNullHandlingTest
     final GroupByTestColumnSelectorFactory columnSelectorFactory = GrouperTestUtil.newColumnSelectorFactory();
     final LimitedBufferHashGrouper<IntKey> grouper = makeGrouper(columnSelectorFactory, 20000);
 
-    Assert.assertEquals(0L, grouper.getMaxMergeBufferUsedBytes());
+    Assertions.assertEquals(0L, grouper.getMaxMergeBufferUsedBytes());
     columnSelectorFactory.setRow(new MapBasedRow(0, ImmutableMap.of("value", 10L)));
 
-    Assert.assertTrue(String.valueOf(KEY_BASE), grouper.aggregate(new IntKey(KEY_BASE)).isOk());
+    Assertions.assertTrue(grouper.aggregate(new IntKey(KEY_BASE)).isOk(), String.valueOf(KEY_BASE));
     final long usagePerEntry = grouper.getMaxMergeBufferUsedBytes();
 
     grouper.reset();
-    Assert.assertEquals(0, grouper.getSize());
-    Assert.assertEquals(usagePerEntry, grouper.getMaxMergeBufferUsedBytes());
+    Assertions.assertEquals(0, grouper.getSize());
+    Assertions.assertEquals(usagePerEntry, grouper.getMaxMergeBufferUsedBytes());
 
     // Add 10 entries after reset
     for (int i = 0; i < 10; i++) {
-      Assert.assertTrue(String.valueOf(i + KEY_BASE), grouper.aggregate(new IntKey(i + KEY_BASE)).isOk());
+      Assertions.assertTrue(grouper.aggregate(new IntKey(i + KEY_BASE)).isOk(), String.valueOf(i + KEY_BASE));
     }
 
-    Assert.assertEquals(10 * usagePerEntry, grouper.getMaxMergeBufferUsedBytes());
+    Assertions.assertEquals(10 * usagePerEntry, grouper.getMaxMergeBufferUsedBytes());
   }
 
   @Test
@@ -341,17 +348,17 @@ public class LimitedBufferHashGrouperTest extends InitializedNullHandlingTest
     columnSelectorFactory.setRow(new MapBasedRow(0, ImmutableMap.of("value", 10L)));
 
     // Calculate usage per entry from first entry
-    Assert.assertTrue(String.valueOf(KEY_BASE), grouper.aggregate(new IntKey(KEY_BASE)).isOk());
+    Assertions.assertTrue(grouper.aggregate(new IntKey(KEY_BASE)).isOk(), String.valueOf(KEY_BASE));
     final long usagePerEntry = grouper.getMaxMergeBufferUsedBytes();
 
     // This results in 13 swaps and final size of 116 (100 keys + 16 new keys after last swap)
     for (int i = 1; i < NUM_ROWS; i++) {
-      Assert.assertTrue(String.valueOf(i + KEY_BASE), grouper.aggregate(new IntKey(i + KEY_BASE)).isOk());
+      Assertions.assertTrue(grouper.aggregate(new IntKey(i + KEY_BASE)).isOk(), String.valueOf(i + KEY_BASE));
     }
 
-    Assert.assertEquals(13, grouper.getGrowthCount());
-    Assert.assertEquals(116, grouper.getSize());
-    Assert.assertEquals(168, grouper.getMaxSize());
+    Assertions.assertEquals(13, grouper.getGrowthCount());
+    Assertions.assertEquals(116, grouper.getSize());
+    Assertions.assertEquals(168, grouper.getMaxSize());
 
     final long bucketSizeWithHash = usagePerEntry - Integer.BYTES;
     final long hashTablePeak = grouper.getMaxSize() * bucketSizeWithHash;
@@ -360,7 +367,7 @@ public class LimitedBufferHashGrouperTest extends InitializedNullHandlingTest
     // Peak usage is the sum of hash table peak and heap peak, which peak at different sizes...
     final long expectedPeakUsage = hashTablePeak + heapPeak;
 
-    Assert.assertEquals(expectedPeakUsage, grouper.getMaxMergeBufferUsedBytes());
+    Assertions.assertEquals(expectedPeakUsage, grouper.getMaxMergeBufferUsedBytes());
   }
 
   private static LimitedBufferHashGrouper<IntKey> makeGrouper(
diff --git a/processing/src/test/java/org/apache/druid/query/groupby/epinephelinae/SpillingGrouperTest.java b/processing/src/test/java/org/apache/druid/query/groupby/epinephelinae/SpillingGrouperTest.java
index 3ec12156823..c3de0b435e0 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/epinephelinae/SpillingGrouperTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/epinephelinae/SpillingGrouperTest.java
@@ -29,10 +29,10 @@ import org.apache.druid.query.aggregation.CountAggregatorFactory;
 import org.apache.druid.query.aggregation.LongSumAggregatorFactory;
 import org.apache.druid.query.groupby.GroupByStatsProvider;
 import org.apache.druid.testing.InitializedNullHandlingTest;
-import org.junit.Assert;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.apache.druid.testing.TemporaryFolderExtension;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
 
 import java.io.File;
 import java.io.IOException;
@@ -52,8 +52,8 @@ public class SpillingGrouperTest extends InitializedNullHandlingTest
   private static final float MAX_LOAD_FACTOR = 0.75f;
   private static final int INITIAL_BUCKETS = 4;
 
-  @Rule
-  public TemporaryFolder temporaryFolder = new TemporaryFolder();
+  @RegisterExtension
+  public TemporaryFolderExtension temporaryFolder = new TemporaryFolderExtension();
 
   @Test
   public void testNoSpilling() throws IOException
@@ -62,11 +62,11 @@ public class SpillingGrouperTest extends InitializedNullHandlingTest
     //  Only 3 keys with a 10,000-byte buffer. Everything fits in memory
     try (SpillingGrouper<IntKey> grouper = makeGrouper(10000, storageDir, 1024 * 1024, 100)) {
       for (int i = 0; i < 3; i++) {
-        Assert.assertTrue(grouper.aggregate(new IntKey(i)).isOk());
+        Assertions.assertTrue(grouper.aggregate(new IntKey(i)).isOk());
       }
 
       assertResultsCorrect(grouper, 3, 1);
-      Assert.assertEquals(0, storageDir.listFiles().length);
+      Assertions.assertEquals(0, storageDir.listFiles().length);
     }
   }
 
@@ -78,25 +78,25 @@ public class SpillingGrouperTest extends InitializedNullHandlingTest
     // 100 unique keys force many spills since buffer is only 50 bytes. With iterator(true), results should be sorted ascending by key.
     try (SpillingGrouper<IntKey> grouper = makeGrouper(50, storageDir, 1024 * 1024, 100)) {
       for (int i = 0; i < numKeys; i++) {
-        Assert.assertTrue(grouper.aggregate(new IntKey(i)).isOk());
+        Assertions.assertTrue(grouper.aggregate(new IntKey(i)).isOk());
       }
 
       try (CloseableIterator<Grouper.Entry<IntKey>> iterator = grouper.iterator(true)) {
-        Assert.assertTrue("spilling should have occurred", storageDir.listFiles().length > 0);
+        Assertions.assertTrue(storageDir.listFiles().length > 0, "spilling should have occurred");
         int prevKey = -1;
         int count = 0;
         while (iterator.hasNext()) {
           Grouper.Entry<IntKey> entry = iterator.next();
-          Assert.assertTrue(
-              "keys should be sorted ascending",
-              entry.getKey().intValue() > prevKey
+          Assertions.assertTrue(
+              entry.getKey().intValue() > prevKey,
+              "keys should be sorted ascending"
           );
           prevKey = entry.getKey().intValue();
-          Assert.assertEquals(1L, entry.getValues()[0]);
-          Assert.assertEquals(1L, entry.getValues()[1]);
+          Assertions.assertEquals(1L, entry.getValues()[0]);
+          Assertions.assertEquals(1L, entry.getValues()[1]);
           count++;
         }
-        Assert.assertEquals(numKeys, count);
+        Assertions.assertEquals(numKeys, count);
       }
     }
   }
@@ -109,11 +109,11 @@ public class SpillingGrouperTest extends InitializedNullHandlingTest
     // 100 unique keys force many spills since buffer is only 50 bytes. With iterator(false), results may be in any order, but all keys should be present with correct values.
     try (SpillingGrouper<IntKey> grouper = makeGrouper(50, storageDir, 1024 * 1024, 100)) {
       for (int i = 0; i < numKeys; i++) {
-        Assert.assertTrue(grouper.aggregate(new IntKey(i)).isOk());
+        Assertions.assertTrue(grouper.aggregate(new IntKey(i)).isOk());
       }
 
       assertResultsCorrect(grouper, numKeys, 1);
-      Assert.assertTrue("spilling should have occurred", storageDir.listFiles().length > 0);
+      Assertions.assertTrue(storageDir.listFiles().length > 0, "spilling should have occurred");
     }
   }
 
@@ -129,31 +129,31 @@ public class SpillingGrouperTest extends InitializedNullHandlingTest
     try (SpillingGrouper<IntKey> grouper = makeGrouper(50, storageDir, 1024 * 1024, 100)) {
       for (int round = 0; round < duplicates; round++) {
         for (int i = 0; i < numKeys; i++) {
-          Assert.assertTrue(grouper.aggregate(new IntKey(i)).isOk());
+          Assertions.assertTrue(grouper.aggregate(new IntKey(i)).isOk());
         }
       }
 
       int totalEntries = 0;
       final Map<Integer, Long> totalCounts = new HashMap<>();
       try (CloseableIterator<Grouper.Entry<IntKey>> iterator = grouper.iterator(true)) {
-        Assert.assertTrue("spilling should have occurred", storageDir.listFiles().length > 0);
+        Assertions.assertTrue(storageDir.listFiles().length > 0, "spilling should have occurred");
         while (iterator.hasNext()) {
           Grouper.Entry<IntKey> entry = iterator.next();
           totalCounts.merge(entry.getKey().intValue(), (Long) entry.getValues()[1], Long::sum);
           totalEntries++;
         }
       }
-      Assert.assertTrue(
+      Assertions.assertTrue(
+          totalEntries > numKeys,
           "duplicate keys should exist across spills, so total entries (" + totalEntries
-          + ") should exceed unique key count (" + numKeys + ")",
-          totalEntries > numKeys
+          + ") should exceed unique key count (" + numKeys + ")"
       );
-      Assert.assertEquals(numKeys, totalCounts.size());
+      Assertions.assertEquals(numKeys, totalCounts.size());
       for (Map.Entry<Integer, Long> e : totalCounts.entrySet()) {
-        Assert.assertEquals(
-            "total count for key " + e.getKey(),
+        Assertions.assertEquals(
             (long) duplicates,
-            (long) e.getValue()
+            (long) e.getValue(),
+            "total count for key " + e.getKey()
         );
       }
     }
@@ -167,25 +167,25 @@ public class SpillingGrouperTest extends InitializedNullHandlingTest
     final int numKeys = 100;
 
     int maxUsableEntries = computeMaxUsableEntries(bufferSize);
-    Assert.assertEquals(
-        "buffer should hold at most 1 entry, guaranteeing a spill on every key",
+    Assertions.assertEquals(
         1,
-        maxUsableEntries
+        maxUsableEntries,
+        "buffer should hold at most 1 entry, guaranteeing a spill on every key"
     );
 
     try (SpillingGrouper<IntKey> grouper = makeGrouper(bufferSize, storageDir, 1024 * 1024, 100)) {
       for (int i = 0; i < numKeys; i++) {
-        Assert.assertTrue(grouper.aggregate(new IntKey(i)).isOk());
+        Assertions.assertTrue(grouper.aggregate(new IntKey(i)).isOk());
       }
 
       assertResultsCorrect(grouper, numKeys, 1);
 
       File[] files = storageDir.listFiles();
-      Assert.assertNotNull(files);
-      Assert.assertEquals(
-          "all spills are tiny and should batch into a single data + dictionary file pair",
+      Assertions.assertNotNull(files);
+      Assertions.assertEquals(
           2,
-          files.length
+          files.length,
+          "all spills are tiny and should batch into a single data + dictionary file pair"
       );
     }
   }
@@ -200,15 +200,15 @@ public class SpillingGrouperTest extends InitializedNullHandlingTest
     final int numKeys = 100;
 
     int maxUsableEntries = computeMaxUsableEntries(bufferSize);
-    Assert.assertEquals(
-        "buffer should hold at most 1 entry, guaranteeing a spill on every key",
+    Assertions.assertEquals(
         1,
-        maxUsableEntries
+        maxUsableEntries,
+        "buffer should hold at most 1 entry, guaranteeing a spill on every key"
     );
 
     try (SpillingGrouper<IntKey> grouper = makeGrouper(bufferSize, temporaryStorage)) {
       for (int i = 0; i < numKeys; i++) {
-        Assert.assertTrue(grouper.aggregate(new IntKey(i)).isOk());
+        Assertions.assertTrue(grouper.aggregate(new IntKey(i)).isOk());
       }
 
       // Before iterator(): small spills were created and deleted during batching, so the
@@ -219,23 +219,23 @@ public class SpillingGrouperTest extends InitializedNullHandlingTest
 
       // With a 50-byte buffer and 100 keys, many individual spills occur. Batching deletes
       // each small temp file immediately, so the file count should be much less than numKeys.
-      Assert.assertTrue(
+      Assertions.assertTrue(
+          fileCountBeforeIterator < numKeys,
           "file count (" + fileCountBeforeIterator + ") should be much less than numKeys (" + numKeys
-          + ") because small spill files are deleted after being read into memory",
-          fileCountBeforeIterator < numKeys
+          + ") because small spill files are deleted after being read into memory"
       );
 
       // The tracked bytes should reflect only the files still on disk, not the deleted ones.
       long actualDiskBytes = 0;
       File[] diskFiles = storageDir.listFiles();
-      Assert.assertNotNull(diskFiles);
+      Assertions.assertNotNull(diskFiles);
       for (File f : diskFiles) {
         actualDiskBytes += f.length();
       }
-      Assert.assertEquals(
-          "tracked bytes should match actual bytes on disk",
+      Assertions.assertEquals(
           actualDiskBytes,
-          sizeBeforeIterator
+          sizeBeforeIterator,
+          "tracked bytes should match actual bytes on disk"
       );
 
       // Calling iterator() flushes remaining pending runs; verify results are still correct.
@@ -245,14 +245,14 @@ public class SpillingGrouperTest extends InitializedNullHandlingTest
       long sizeAfterIterator = temporaryStorage.currentSize();
       long actualDiskBytesAfter = 0;
       File[] diskFilesAfter = storageDir.listFiles();
-      Assert.assertNotNull(diskFilesAfter);
+      Assertions.assertNotNull(diskFilesAfter);
       for (File f : diskFilesAfter) {
         actualDiskBytesAfter += f.length();
       }
-      Assert.assertEquals(
-          "tracked bytes should match actual bytes on disk after iterator",
+      Assertions.assertEquals(
           actualDiskBytesAfter,
-          sizeAfterIterator
+          sizeAfterIterator,
+          "tracked bytes should match actual bytes on disk after iterator"
       );
     }
   }
@@ -262,26 +262,26 @@ public class SpillingGrouperTest extends InitializedNullHandlingTest
   {
     try (SpillingGrouper<IntKey> grouper = makeGrouper(50, temporaryFolder.newFolder(), 1024 * 1024, 100)) {
       for (int i = 0; i < 50; i++) {
-        Assert.assertTrue(grouper.aggregate(new IntKey(i)).isOk());
+        Assertions.assertTrue(grouper.aggregate(new IntKey(i)).isOk());
       }
 
       grouper.reset();
 
       for (int i = 1000; i < 1010; i++) {
-        Assert.assertTrue(grouper.aggregate(new IntKey(i)).isOk());
+        Assertions.assertTrue(grouper.aggregate(new IntKey(i)).isOk());
       }
 
       try (CloseableIterator<Grouper.Entry<IntKey>> iterator = grouper.iterator(true)) {
         int count = 0;
         while (iterator.hasNext()) {
           Grouper.Entry<IntKey> entry = iterator.next();
-          Assert.assertTrue(
-              "keys should be >= 1000 after reset",
-              entry.getKey().intValue() >= 1000
+          Assertions.assertTrue(
+              entry.getKey().intValue() >= 1000,
+              "keys should be >= 1000 after reset"
           );
           count++;
         }
-        Assert.assertEquals(10, count);
+        Assertions.assertEquals(10, count);
       }
     }
   }
@@ -300,17 +300,17 @@ public class SpillingGrouperTest extends InitializedNullHandlingTest
       // Aggregate enough keys to trigger multiple spills, but not enough to exceed
       // minSpillFileSize in total pending bytes.
       for (int i = 0; i < 20; i++) {
-        Assert.assertTrue(grouper.aggregate(new IntKey(i)).isOk());
+        Assertions.assertTrue(grouper.aggregate(new IntKey(i)).isOk());
       }
 
       // No files should have been created — all spills are below the threshold and
       // pending bytes haven't reached minSpillFileSize yet.
-      Assert.assertEquals(
-          "small spills should stay in memory without creating any temp files",
+      Assertions.assertEquals(
           0,
-          temporaryStorage.currentFileCount()
+          temporaryStorage.currentFileCount(),
+          "small spills should stay in memory without creating any temp files"
       );
-      Assert.assertEquals(0, storageDir.listFiles().length);
+      Assertions.assertEquals(0, storageDir.listFiles().length);
 
       // Results should still be correct when iterated.
       assertResultsCorrect(grouper, 20, 1);
@@ -328,10 +328,10 @@ public class SpillingGrouperTest extends InitializedNullHandlingTest
         lastResult = grouper.aggregate(new IntKey(i));
       }
 
-      Assert.assertFalse("should have hit disk full", lastResult.isOk());
-      Assert.assertTrue(
-          "reason should mention disk space",
-          lastResult.getReason().contains("Not enough disk space")
+      Assertions.assertFalse(lastResult.isOk(), "should have hit disk full");
+      Assertions.assertTrue(
+          lastResult.getReason().contains("Not enough disk space"),
+          "reason should mention disk space"
       );
     }
   }
@@ -359,15 +359,15 @@ public class SpillingGrouperTest extends InitializedNullHandlingTest
         }
       }
 
-      Assert.assertFalse("should have hit max file count", lastResult.isOk());
-      Assert.assertTrue(
-          "reason should mention spill file count",
-          lastResult.getReason().contains("Maximum number of spill files")
+      Assertions.assertFalse(lastResult.isOk(), "should have hit max file count");
+      Assertions.assertTrue(
+          lastResult.getReason().contains("Maximum number of spill files"),
+          "reason should mention spill file count"
       );
-      Assert.assertTrue(
+      Assertions.assertTrue(
+          keysAggregated > maxUsableEntries * 2,
           "batching should allow many keys (" + keysAggregated + ") before hitting file limit;"
-          + " without batching only ~" + (maxUsableEntries * 2) + " would succeed",
-          keysAggregated > maxUsableEntries * 2
+          + " without batching only ~" + (maxUsableEntries * 2) + " would succeed"
       );
     }
   }
@@ -448,20 +448,20 @@ public class SpillingGrouperTest extends InitializedNullHandlingTest
         int key = entry.getKey().intValue();
         Object[] valuesCopy = new Object[entry.getValues().length];
         System.arraycopy(entry.getValues(), 0, valuesCopy, 0, valuesCopy.length);
-        Assert.assertNull("duplicate key in results: " + key, results.put(key, valuesCopy));
+        Assertions.assertNull(results.put(key, valuesCopy), "duplicate key in results: " + key);
       }
     }
-    Assert.assertEquals(expectedKeys, results.size());
+    Assertions.assertEquals(expectedKeys, results.size());
     for (Map.Entry<Integer, Object[]> e : results.entrySet()) {
-      Assert.assertEquals(
-          "valueSum for key " + e.getKey(),
+      Assertions.assertEquals(
           expectedCountPerKey,
-          e.getValue()[0]
+          e.getValue()[0],
+          "valueSum for key " + e.getKey()
       );
-      Assert.assertEquals(
-          "count for key " + e.getKey(),
+      Assertions.assertEquals(
           expectedCountPerKey,
-          e.getValue()[1]
+          e.getValue()[1],
+          "count for key " + e.getKey()
       );
     }
   }
diff --git a/processing/src/test/java/org/apache/druid/query/groupby/epinephelinae/column/FixedWidthGroupByColumnSelectorStrategyTest.java b/processing/src/test/java/org/apache/druid/query/groupby/epinephelinae/column/FixedWidthGroupByColumnSelectorStrategyTest.java
index 628ce7391c3..52e4ca7fc2e 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/epinephelinae/column/FixedWidthGroupByColumnSelectorStrategyTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/epinephelinae/column/FixedWidthGroupByColumnSelectorStrategyTest.java
@@ -29,11 +29,12 @@ import org.apache.druid.segment.Cursor;
 import org.apache.druid.segment.column.ColumnType;
 import org.apache.druid.segment.column.RowSignature;
 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 org.mockito.Mockito;
 
 import javax.annotation.Nullable;
+
 import java.nio.ByteBuffer;
 import java.util.List;
 
@@ -64,7 +65,7 @@ public class FixedWidthGroupByColumnSelectorStrategyTest extends InitializedNull
     @Test
     public void testKeySize()
     {
-      Assert.assertEquals(Byte.BYTES + Long.BYTES, STRATEGY.getGroupingKeySizeBytes());
+      Assertions.assertEquals(Byte.BYTES + Long.BYTES, STRATEGY.getGroupingKeySizeBytes());
     }
 
     @Test
@@ -82,8 +83,8 @@ public class FixedWidthGroupByColumnSelectorStrategyTest extends InitializedNull
         int sizeIncrease = STRATEGY.writeToKeyBuffer(0, columnValueSelector, BUFFER1);
         STRATEGY.processValueFromGroupingKey(groupByColumnSelectorPlus, BUFFER1, resultRow, 0);
         // There shouldn't be any internal size increase associated with the fixed width types
-        Assert.assertEquals(0, sizeIncrease);
-        Assert.assertEquals(DATASOURCE_ROWS.get(rowNum)[0], resultRow.get(0));
+        Assertions.assertEquals(0, sizeIncrease);
+        Assertions.assertEquals(DATASOURCE_ROWS.get(rowNum)[0], resultRow.get(0));
         cursor.advance();
         ++rowNum;
       }
@@ -99,8 +100,8 @@ public class FixedWidthGroupByColumnSelectorStrategyTest extends InitializedNull
       int rowNum = 0;
       while (!cursor.isDone()) {
         int sizeIncrease = STRATEGY.initColumnValues(columnValueSelector, 0, valuess);
-        Assert.assertEquals(0, sizeIncrease);
-        Assert.assertEquals(DATASOURCE_ROWS.get(rowNum)[0], valuess[0]);
+        Assertions.assertEquals(0, sizeIncrease);
+        Assertions.assertEquals(DATASOURCE_ROWS.get(rowNum)[0], valuess[0]);
         cursor.advance();
         ++rowNum;
       }
@@ -112,37 +113,37 @@ public class FixedWidthGroupByColumnSelectorStrategyTest extends InitializedNull
       // lhs < rhs
       writeGroupingKeyToBuffer(BUFFER1, 100L);
       writeGroupingKeyToBuffer(BUFFER2, 200L);
-      Assert.assertEquals(-1, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
+      Assertions.assertEquals(-1, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
 
       // lhs == rhs
       writeGroupingKeyToBuffer(BUFFER1, 100L);
       writeGroupingKeyToBuffer(BUFFER2, 100L);
-      Assert.assertEquals(0, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
+      Assertions.assertEquals(0, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
 
       // lhs > rhs
       writeGroupingKeyToBuffer(BUFFER1, 200L);
       writeGroupingKeyToBuffer(BUFFER2, 100L);
-      Assert.assertEquals(1, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
+      Assertions.assertEquals(1, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
 
       // lhs is null
       writeGroupingKeyToBuffer(BUFFER1, null);
       writeGroupingKeyToBuffer(BUFFER2, 0L);
-      Assert.assertEquals(-1, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
+      Assertions.assertEquals(-1, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
 
       // rhs is null
       writeGroupingKeyToBuffer(BUFFER1, 0L);
       writeGroupingKeyToBuffer(BUFFER2, null);
-      Assert.assertEquals(1, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
+      Assertions.assertEquals(1, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
 
       // lhs and rhs are null
       writeGroupingKeyToBuffer(BUFFER1, null);
       writeGroupingKeyToBuffer(BUFFER2, null);
-      Assert.assertEquals(0, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
+      Assertions.assertEquals(0, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
 
       // stringComparator is provided, for lexicographic comparator "2" > "100"
       writeGroupingKeyToBuffer(BUFFER1, 2L);
       writeGroupingKeyToBuffer(BUFFER2, 100L);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           1,
           STRATEGY.bufferComparator(0, StringComparators.LEXICOGRAPHIC)
                   .compare(BUFFER1, BUFFER2, 0, 0)
@@ -151,7 +152,7 @@ public class FixedWidthGroupByColumnSelectorStrategyTest extends InitializedNull
       // stringComparator is provided, for alphanumeric comparator number("2") < number("100")
       writeGroupingKeyToBuffer(BUFFER1, 2L);
       writeGroupingKeyToBuffer(BUFFER2, 100L);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           -1,
           STRATEGY.bufferComparator(0, StringComparators.ALPHANUMERIC)
                   .compare(BUFFER1, BUFFER2, 0, 0)
@@ -166,15 +167,15 @@ public class FixedWidthGroupByColumnSelectorStrategyTest extends InitializedNull
       Mockito.when(columnValueSelector1.getLong()).thenReturn(key == null ? 0 : key);
       Mockito.when(columnValueSelector1.isNull()).thenReturn(key == null);
 
-      Assert.assertEquals(0, STRATEGY.writeToKeyBuffer(0, columnValueSelector1, buffer));
+      Assertions.assertEquals(0, STRATEGY.writeToKeyBuffer(0, columnValueSelector1, buffer));
     }
 
     @Test
     public void testMultiValueHandling()
     {
       // Returns false, because fixed width strategy doesn't handle multi-value dimensions, therefore it returns false
-      Assert.assertFalse(STRATEGY.checkRowIndexAndAddValueToGroupingKey(0, 1L, 0, BUFFER1));
-      Assert.assertFalse(STRATEGY.checkRowIndexAndAddValueToGroupingKey(0, 1L, 10, BUFFER1));
+      Assertions.assertFalse(STRATEGY.checkRowIndexAndAddValueToGroupingKey(0, 1L, 0, BUFFER1));
+      Assertions.assertFalse(STRATEGY.checkRowIndexAndAddValueToGroupingKey(0, 1L, 10, BUFFER1));
     }
 
     @Test
@@ -186,15 +187,15 @@ public class FixedWidthGroupByColumnSelectorStrategyTest extends InitializedNull
       ResultRow resultRow = ResultRow.create(1);
 
       STRATEGY.initGroupingKeyColumnValue(0, 0, 1001L, BUFFER1, stack);
-      Assert.assertEquals(1, stack[0]);
+      Assertions.assertEquals(1, stack[0]);
       STRATEGY.processValueFromGroupingKey(groupByColumnSelectorPlus, BUFFER1, resultRow, 0);
-      Assert.assertEquals(1001L, resultRow.get(0));
+      Assertions.assertEquals(1001L, resultRow.get(0));
 
 
       STRATEGY.initGroupingKeyColumnValue(0, 0, null, BUFFER1, stack);
-      Assert.assertEquals(0, stack[0]);
+      Assertions.assertEquals(0, stack[0]);
       STRATEGY.processValueFromGroupingKey(groupByColumnSelectorPlus, BUFFER1, resultRow, 0);
-      Assert.assertEquals(null, resultRow.get(0));
+      Assertions.assertEquals(null, resultRow.get(0));
     }
   }
 
@@ -210,7 +211,7 @@ public class FixedWidthGroupByColumnSelectorStrategyTest extends InitializedNull
     @Test
     public void testKeySize()
     {
-      Assert.assertEquals(Byte.BYTES + Float.BYTES, STRATEGY.getGroupingKeySizeBytes());
+      Assertions.assertEquals(Byte.BYTES + Float.BYTES, STRATEGY.getGroupingKeySizeBytes());
     }
 
     @Test
@@ -226,8 +227,8 @@ public class FixedWidthGroupByColumnSelectorStrategyTest extends InitializedNull
       while (!cursor.isDone()) {
         int sizeIncrease = STRATEGY.writeToKeyBuffer(0, columnValueSelector, BUFFER1);
         STRATEGY.processValueFromGroupingKey(groupByColumnSelectorPlus, BUFFER1, resultRow, 0);
-        Assert.assertEquals(0, sizeIncrease);
-        Assert.assertEquals(DATASOURCE_ROWS.get(rowNum)[1], resultRow.get(0));
+        Assertions.assertEquals(0, sizeIncrease);
+        Assertions.assertEquals(DATASOURCE_ROWS.get(rowNum)[1], resultRow.get(0));
         cursor.advance();
         ++rowNum;
       }
@@ -243,8 +244,8 @@ public class FixedWidthGroupByColumnSelectorStrategyTest extends InitializedNull
       int rowNum = 0;
       while (!cursor.isDone()) {
         int sizeIncrease = STRATEGY.initColumnValues(columnValueSelector, 0, valuess);
-        Assert.assertEquals(0, sizeIncrease);
-        Assert.assertEquals(DATASOURCE_ROWS.get(rowNum)[1], valuess[0]);
+        Assertions.assertEquals(0, sizeIncrease);
+        Assertions.assertEquals(DATASOURCE_ROWS.get(rowNum)[1], valuess[0]);
         cursor.advance();
         ++rowNum;
       }
@@ -256,37 +257,37 @@ public class FixedWidthGroupByColumnSelectorStrategyTest extends InitializedNull
       // lhs < rhs
       writeGroupingKeyToBuffer(BUFFER1, 100.0F);
       writeGroupingKeyToBuffer(BUFFER2, 200.0F);
-      Assert.assertEquals(-1, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
+      Assertions.assertEquals(-1, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
 
       // lhs == rhs
       writeGroupingKeyToBuffer(BUFFER1, 100.0F);
       writeGroupingKeyToBuffer(BUFFER2, 100.0F);
-      Assert.assertEquals(0, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
+      Assertions.assertEquals(0, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
 
       // lhs > rhs
       writeGroupingKeyToBuffer(BUFFER1, 200.0F);
       writeGroupingKeyToBuffer(BUFFER2, 100.0F);
-      Assert.assertEquals(1, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
+      Assertions.assertEquals(1, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
 
       // lhs is null
       writeGroupingKeyToBuffer(BUFFER1, null);
       writeGroupingKeyToBuffer(BUFFER2, 0.0F);
-      Assert.assertEquals(-1, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
+      Assertions.assertEquals(-1, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
 
       // rhs is null
       writeGroupingKeyToBuffer(BUFFER1, 0.0F);
       writeGroupingKeyToBuffer(BUFFER2, null);
-      Assert.assertEquals(1, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
+      Assertions.assertEquals(1, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
 
       // lhs and rhs are null
       writeGroupingKeyToBuffer(BUFFER1, null);
       writeGroupingKeyToBuffer(BUFFER2, null);
-      Assert.assertEquals(0, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
+      Assertions.assertEquals(0, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
 
       // stringComparator is provided, for lexicographic comparator "2.0" > "100.0"
       writeGroupingKeyToBuffer(BUFFER1, 2.0F);
       writeGroupingKeyToBuffer(BUFFER2, 100.0F);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           1,
           STRATEGY.bufferComparator(0, StringComparators.LEXICOGRAPHIC)
                   .compare(BUFFER1, BUFFER2, 0, 0)
@@ -295,7 +296,7 @@ public class FixedWidthGroupByColumnSelectorStrategyTest extends InitializedNull
       // stringComparator is provided, for alphanumeric comparator number("2") < number("100")
       writeGroupingKeyToBuffer(BUFFER1, 2.0F);
       writeGroupingKeyToBuffer(BUFFER2, 100.0F);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           -1,
           STRATEGY.bufferComparator(0, StringComparators.ALPHANUMERIC)
                   .compare(BUFFER1, BUFFER2, 0, 0)
@@ -310,15 +311,15 @@ public class FixedWidthGroupByColumnSelectorStrategyTest extends InitializedNull
       Mockito.when(columnValueSelector1.getFloat()).thenReturn(key == null ? 0.0f : key);
       Mockito.when(columnValueSelector1.isNull()).thenReturn(key == null);
 
-      Assert.assertEquals(0, STRATEGY.writeToKeyBuffer(0, columnValueSelector1, buffer));
+      Assertions.assertEquals(0, STRATEGY.writeToKeyBuffer(0, columnValueSelector1, buffer));
     }
 
     @Test
     public void testMultiValueHandling()
     {
       // Returns false, because fixed width strategy doesn't handle multi-value dimensions, therefore it returns false
-      Assert.assertFalse(STRATEGY.checkRowIndexAndAddValueToGroupingKey(0, 1.0F, 0, BUFFER1));
-      Assert.assertFalse(STRATEGY.checkRowIndexAndAddValueToGroupingKey(0, 1.0F, 10, BUFFER1));
+      Assertions.assertFalse(STRATEGY.checkRowIndexAndAddValueToGroupingKey(0, 1.0F, 0, BUFFER1));
+      Assertions.assertFalse(STRATEGY.checkRowIndexAndAddValueToGroupingKey(0, 1.0F, 10, BUFFER1));
     }
 
     @Test
@@ -330,15 +331,15 @@ public class FixedWidthGroupByColumnSelectorStrategyTest extends InitializedNull
       ResultRow resultRow = ResultRow.create(1);
 
       STRATEGY.initGroupingKeyColumnValue(0, 0, 1001.0F, BUFFER1, stack);
-      Assert.assertEquals(1, stack[0]);
+      Assertions.assertEquals(1, stack[0]);
       STRATEGY.processValueFromGroupingKey(groupByColumnSelectorPlus, BUFFER1, resultRow, 0);
-      Assert.assertEquals(1001.0F, resultRow.get(0));
+      Assertions.assertEquals(1001.0F, resultRow.get(0));
 
 
       STRATEGY.initGroupingKeyColumnValue(0, 0, null, BUFFER1, stack);
-      Assert.assertEquals(0, stack[0]);
+      Assertions.assertEquals(0, stack[0]);
       STRATEGY.processValueFromGroupingKey(groupByColumnSelectorPlus, BUFFER1, resultRow, 0);
-      Assert.assertEquals(null, resultRow.get(0));
+      Assertions.assertEquals(null, resultRow.get(0));
     }
   }
 
@@ -354,7 +355,7 @@ public class FixedWidthGroupByColumnSelectorStrategyTest extends InitializedNull
     @Test
     public void testKeySize()
     {
-      Assert.assertEquals(Byte.BYTES + Double.BYTES, STRATEGY.getGroupingKeySizeBytes());
+      Assertions.assertEquals(Byte.BYTES + Double.BYTES, STRATEGY.getGroupingKeySizeBytes());
     }
 
     @Test
@@ -371,8 +372,8 @@ public class FixedWidthGroupByColumnSelectorStrategyTest extends InitializedNull
       while (!cursor.isDone()) {
         int sizeIncrease = STRATEGY.writeToKeyBuffer(0, columnValueSelector, BUFFER1);
         STRATEGY.processValueFromGroupingKey(groupByColumnSelectorPlus, BUFFER1, resultRow, 0);
-        Assert.assertEquals(0, sizeIncrease);
-        Assert.assertEquals(
+        Assertions.assertEquals(0, sizeIncrease);
+        Assertions.assertEquals(
             DATASOURCE_ROWS.get(rowNum)[2],
             resultRow.get(0)
         );
@@ -392,8 +393,8 @@ public class FixedWidthGroupByColumnSelectorStrategyTest extends InitializedNull
       int rowNum = 0;
       while (!cursor.isDone()) {
         int sizeIncrease = STRATEGY.initColumnValues(columnValueSelector, 0, valuess);
-        Assert.assertEquals(0, sizeIncrease);
-        Assert.assertEquals(DATASOURCE_ROWS.get(rowNum)[2], valuess[0]);
+        Assertions.assertEquals(0, sizeIncrease);
+        Assertions.assertEquals(DATASOURCE_ROWS.get(rowNum)[2], valuess[0]);
         cursor.advance();
         ++rowNum;
       }
@@ -405,37 +406,37 @@ public class FixedWidthGroupByColumnSelectorStrategyTest extends InitializedNull
       // lhs < rhs
       writeGroupingKeyToBuffer(BUFFER1, 100.0D);
       writeGroupingKeyToBuffer(BUFFER2, 200.0D);
-      Assert.assertEquals(-1, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
+      Assertions.assertEquals(-1, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
 
       // lhs == rhs
       writeGroupingKeyToBuffer(BUFFER1, 100.0D);
       writeGroupingKeyToBuffer(BUFFER2, 100.0D);
-      Assert.assertEquals(0, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
+      Assertions.assertEquals(0, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
 
       // lhs > rhs
       writeGroupingKeyToBuffer(BUFFER1, 200.0D);
       writeGroupingKeyToBuffer(BUFFER2, 100.0D);
-      Assert.assertEquals(1, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
+      Assertions.assertEquals(1, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
 
       // lhs is null
       writeGroupingKeyToBuffer(BUFFER1, null);
       writeGroupingKeyToBuffer(BUFFER2, 0.0D);
-      Assert.assertEquals(-1, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
+      Assertions.assertEquals(-1, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
 
       // rhs is null
       writeGroupingKeyToBuffer(BUFFER1, 0.0D);
       writeGroupingKeyToBuffer(BUFFER2, null);
-      Assert.assertEquals(1, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
+      Assertions.assertEquals(1, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
 
       // lhs and rhs are null
       writeGroupingKeyToBuffer(BUFFER1, null);
       writeGroupingKeyToBuffer(BUFFER2, null);
-      Assert.assertEquals(0, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
+      Assertions.assertEquals(0, STRATEGY.bufferComparator(0, null).compare(BUFFER1, BUFFER2, 0, 0));
 
       // stringComparator is provided, for lexicographic comparator "2.0" > "100.0"
       writeGroupingKeyToBuffer(BUFFER1, 2.0D);
       writeGroupingKeyToBuffer(BUFFER2, 100.0D);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           1,
           STRATEGY.bufferComparator(0, StringComparators.LEXICOGRAPHIC)
                   .compare(BUFFER1, BUFFER2, 0, 0)
@@ -444,7 +445,7 @@ public class FixedWidthGroupByColumnSelectorStrategyTest extends InitializedNull
       // stringComparator is provided, for alphanumeric comparator number("2.0D") < number("100.0D")
       writeGroupingKeyToBuffer(BUFFER1, 2.0D);
       writeGroupingKeyToBuffer(BUFFER2, 100.0D);
-      Assert.assertEquals(
+      Assertions.assertEquals(
           -1,
           STRATEGY.bufferComparator(0, StringComparators.ALPHANUMERIC)
                   .compare(BUFFER1, BUFFER2, 0, 0)
@@ -459,15 +460,15 @@ public class FixedWidthGroupByColumnSelectorStrategyTest extends InitializedNull
       Mockito.when(columnValueSelector1.getDouble()).thenReturn(key == null ? 0.0d : key);
       Mockito.when(columnValueSelector1.isNull()).thenReturn(key == null);
 
-      Assert.assertEquals(0, STRATEGY.writeToKeyBuffer(0, columnValueSelector1, buffer));
+      Assertions.assertEquals(0, STRATEGY.writeToKeyBuffer(0, columnValueSelector1, buffer));
     }
 
     @Test
     public void testMultiValueHandling()
     {
       // Returns false, because fixed width strategy doesn't handle multi-value dimensions, therefore it returns false
-      Assert.assertFalse(STRATEGY.checkRowIndexAndAddValueToGroupingKey(0, 1.0D, 0, BUFFER1));
-      Assert.assertFalse(STRATEGY.checkRowIndexAndAddValueToGroupingKey(0, 1.0D, 10, BUFFER1));
+      Assertions.assertFalse(STRATEGY.checkRowIndexAndAddValueToGroupingKey(0, 1.0D, 0, BUFFER1));
+      Assertions.assertFalse(STRATEGY.checkRowIndexAndAddValueToGroupingKey(0, 1.0D, 10, BUFFER1));
     }
 
     @Test
@@ -479,15 +480,15 @@ public class FixedWidthGroupByColumnSelectorStrategyTest extends InitializedNull
       ResultRow resultRow = ResultRow.create(1);
 
       STRATEGY.initGroupingKeyColumnValue(0, 0, 1001.0D, BUFFER1, stack);
-      Assert.assertEquals(1, stack[0]);
+      Assertions.assertEquals(1, stack[0]);
       STRATEGY.processValueFromGroupingKey(groupByColumnSelectorPlus, BUFFER1, resultRow, 0);
-      Assert.assertEquals(1001.0D, resultRow.get(0));
+      Assertions.assertEquals(1001.0D, resultRow.get(0));
 
 
       STRATEGY.initGroupingKeyColumnValue(0, 0, null, BUFFER1, stack);
-      Assert.assertEquals(0, stack[0]);
+      Assertions.assertEquals(0, stack[0]);
       STRATEGY.processValueFromGroupingKey(groupByColumnSelectorPlus, BUFFER1, resultRow, 0);
-      Assert.assertEquals(null, resultRow.get(0));
+      Assertions.assertEquals(null, resultRow.get(0));
     }
   }
 
diff --git a/processing/src/test/java/org/apache/druid/query/groupby/orderby/DefaultLimitSpecTest.java b/processing/src/test/java/org/apache/druid/query/groupby/orderby/DefaultLimitSpecTest.java
index cb1c8939710..07e979e2d4c 100644
--- a/processing/src/test/java/org/apache/druid/query/groupby/orderby/DefaultLimitSpecTest.java
+++ b/processing/src/test/java/org/apache/druid/query/groupby/orderby/DefaultLimitSpecTest.java
@@ -35,10 +35,8 @@ import org.apache.druid.query.groupby.ResultRow;
 import org.apache.druid.query.ordering.StringComparators;
 import org.apache.druid.segment.TestHelper;
 import org.apache.druid.segment.column.ColumnType;
-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.Test;
 
 import java.util.List;
 
@@ -47,9 +45,6 @@ import java.util.List;
  */
 public class DefaultLimitSpecTest
 {
-  @Rule
-  public final ExpectedException expectedException = ExpectedException.none();
-
   private final List<ResultRow> testRowsList;
   private final List<ResultRow> testRowsWithTimestampList;
 
@@ -81,7 +76,7 @@ public class DefaultLimitSpecTest
         LimitSpec.class
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         new DefaultLimitSpec(null, null),
         spec
     );
@@ -96,7 +91,7 @@ public class DefaultLimitSpecTest
         mapper.writeValueAsString(mapper.readValue(json, LimitSpec.class)),
         LimitSpec.class
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         new DefaultLimitSpec(ImmutableList.of(new OrderByColumnSpec("d", OrderByColumnSpec.Direction.DESCENDING,
                                                                     StringComparators.NUMERIC
         )), 10),
@@ -114,7 +109,7 @@ public class DefaultLimitSpecTest
         LimitSpec.class
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         new DefaultLimitSpec(ImmutableList.of(new OrderByColumnSpec("d", OrderByColumnSpec.Direction.DESCENDING,
                                                                     StringComparators.NUMERIC
         )), 10),
@@ -130,7 +125,7 @@ public class DefaultLimitSpecTest
         mapper.writeValueAsString(mapper.readValue(json, LimitSpec.class)),
         LimitSpec.class
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         new DefaultLimitSpec(ImmutableList.of(new OrderByColumnSpec("d", OrderByColumnSpec.Direction.ASCENDING,
                                                                     StringComparators.LEXICOGRAPHIC
         )), 10),
@@ -146,7 +141,7 @@ public class DefaultLimitSpecTest
         mapper.writeValueAsString(mapper.readValue(json, LimitSpec.class)),
         LimitSpec.class
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         new DefaultLimitSpec(ImmutableList.of(new OrderByColumnSpec("d", OrderByColumnSpec.Direction.ASCENDING,
                                                                     StringComparators.LEXICOGRAPHIC
         )), 10),
@@ -172,7 +167,7 @@ public class DefaultLimitSpecTest
                     .build()
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(testRowsWithTimestampList.get(0), testRowsWithTimestampList.get(1)),
         limitFn.apply(Sequences.simple(testRowsWithTimestampList)).toList()
     );
@@ -196,7 +191,7 @@ public class DefaultLimitSpecTest
                     .build()
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(testRowsList.get(0), testRowsList.get(1)),
         limitFn.apply(Sequences.simple(testRowsList)).toList()
     );
@@ -220,7 +215,7 @@ public class DefaultLimitSpecTest
                     .build()
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(testRowsWithTimestampList.get(2), testRowsWithTimestampList.get(0)),
         limitFn.apply(Sequences.simple(testRowsWithTimestampList)).toList()
     );
@@ -244,7 +239,7 @@ public class DefaultLimitSpecTest
     );
 
     // No sorting, because the limit spec thinks sorting isn't necessary (it expects results naturally ordered on k1)
-    Assert.assertEquals(
+    Assertions.assertEquals(
         testRowsList,
         limitFn.apply(Sequences.simple(testRowsList)).toList()
     );
@@ -269,7 +264,7 @@ public class DefaultLimitSpecTest
     );
 
     // limit spec sorts rows because subtotalsSpec is set. (Otherwise, it wouldn't; see testSortByDimNullSubtotals.)
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(testRowsList.get(2), testRowsList.get(0), testRowsList.get(1)),
         limitFn.apply(Sequences.simple(testRowsList)).toList()
     );
@@ -294,7 +289,7 @@ public class DefaultLimitSpecTest
     );
 
     // limit spec sorts rows because subtotalsSpec is set. (Otherwise, it wouldn't; see testSortByDimNullSubtotals.)
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(testRowsList.get(2), testRowsList.get(0), testRowsList.get(1)),
         limitFn.apply(Sequences.simple(testRowsList)).toList()
     );
@@ -319,7 +314,7 @@ public class DefaultLimitSpecTest
 
     // Note: This test encodes the fact that limitSpec sorts numbers like strings; we might want to change this
     // in the future.
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(testRowsList.get(2), testRowsList.get(1)),
         limitFn.apply(Sequences.simple(testRowsList)).toList()
     );
@@ -345,7 +340,7 @@ public class DefaultLimitSpecTest
                     .setGranularity(Granularities.NONE)
                     .build()
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(testRowsList.get(0), testRowsList.get(1)),
         limitFn.apply(Sequences.simple(testRowsList)).toList()
     );
@@ -355,7 +350,7 @@ public class DefaultLimitSpecTest
   public void testWithOffsetToLimit()
   {
     final DefaultLimitSpec limitSpec = DefaultLimitSpec.builder().orderBy("abc").limit(1).offset(2).build();
-    Assert.assertEquals(
+    Assertions.assertEquals(
         DefaultLimitSpec.builder().orderBy("abc").limit(3).build(),
         limitSpec.withOffsetToLimit()
     );
@@ -365,7 +360,7 @@ public class DefaultLimitSpecTest
   public void testWithOffsetToLimitUnlimited()
   {
     final DefaultLimitSpec limitSpec = DefaultLimitSpec.builder().orderBy("abc").offset(2).build();
-    Assert.assertEquals(
+    Assertions.assertEquals(
         DefaultLimitSpec.builder().orderBy("abc").build(),
         limitSpec.withOffsetToLimit()
     );
@@ -377,10 +372,13 @@ public class DefaultLimitSpecTest
     final DefaultLimitSpec limitSpec =
         DefaultLimitSpec.builder().orderBy("abc").limit(Integer.MAX_VALUE - 1).offset(2).build();
 
-    expectedException.expect(IllegalStateException.class);
-    expectedException.expectMessage("Cannot apply limit[2147483646] with offset[2] due to overflow");
-
-    limitSpec.withOffsetToLimit();
+    final IllegalStateException exception = Assertions.assertThrows(
+        IllegalStateException.class,
+        limitSpec::withOffsetToLimit
+    );
+    Assertions.assertTrue(
+        exception.getMessage().contains("Cannot apply limit[2147483646] with offset[2] due to overflow")
+    );
   }
 
   @Test
@@ -412,11 +410,11 @@ public class DefaultLimitSpecTest
     );
 
     List<ResultRow> result = limitFn.apply(Sequences.simple(rowsWithNulls)).toList();
-    Assert.assertEquals(3, result.size());
+    Assertions.assertEquals(3, result.size());
     // Null should sort first in ascending order
-    Assert.assertNull(result.get(0).get(0));
-    Assert.assertEquals("a", result.get(1).get(0));
-    Assert.assertEquals("b", result.get(2).get(0));
+    Assertions.assertNull(result.get(0).get(0));
+    Assertions.assertEquals("a", result.get(1).get(0));
+    Assertions.assertEquals("b", result.get(2).get(0));
   }
 
   @Test
@@ -445,10 +443,10 @@ public class DefaultLimitSpecTest
     );
 
     List<ResultRow> result = limitFn.apply(Sequences.simple(rowsWithNulls)).toList();
-    Assert.assertEquals(3, result.size());
+    Assertions.assertEquals(3, result.size());
     // Null should sort last in descending order
-    Assert.assertEquals("b", result.get(0).get(0));
-    Assert.assertEquals("a", result.get(1).get(0));
-    Assert.assertNull(result.get(2).get(0));
+    Assertions.assertEquals("b", result.get(0).get(0));
+    Assertions.assertEquals("a", result.get(1).get(0));
+    Assertions.assertNull(result.get(2).get(0));
   }
 }
diff --git a/processing/src/test/java/org/apache/druid/query/lookup/LookupExtractionFnTest.java b/processing/src/test/java/org/apache/druid/query/lookup/LookupExtractionFnTest.java
index 8fea4469415..296c3ef5c4d 100644
--- a/processing/src/test/java/org/apache/druid/query/lookup/LookupExtractionFnTest.java
+++ b/processing/src/test/java/org/apache/druid/query/lookup/LookupExtractionFnTest.java
@@ -28,10 +28,10 @@ import com.google.common.collect.Sets;
 import org.apache.druid.jackson.DefaultObjectMapper;
 import org.apache.druid.java.util.common.IAE;
 import org.apache.druid.query.extraction.MapLookupExtractor;
-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.Test;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import java.io.IOException;
 import java.util.Arrays;
@@ -40,10 +40,11 @@ import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 
-@RunWith(Parameterized.class)
+@ParameterizedClass
+
+@MethodSource("constructorFeeder")
 public class LookupExtractionFnTest
 {
-  @Parameterized.Parameters
   public static Iterable<Object[]> constructorFeeder()
   {
     return Iterables.transform(
@@ -101,10 +102,10 @@ public class LookupExtractionFnTest
         false
     );
 
-    Assert.assertEquals(lookupExtractionFn1, lookupExtractionFn2);
-    Assert.assertEquals(lookupExtractionFn1.hashCode(), lookupExtractionFn2.hashCode());
-    Assert.assertNotEquals(lookupExtractionFn1, lookupExtractionFn3);
-    Assert.assertNotEquals(lookupExtractionFn1.hashCode(), lookupExtractionFn3.hashCode());
+    Assertions.assertEquals(lookupExtractionFn1, lookupExtractionFn2);
+    Assertions.assertEquals(lookupExtractionFn1.hashCode(), lookupExtractionFn2.hashCode());
+    Assertions.assertNotEquals(lookupExtractionFn1, lookupExtractionFn3);
+    Assertions.assertNotEquals(lookupExtractionFn1.hashCode(), lookupExtractionFn3.hashCode());
   }
 
   @Test
@@ -125,38 +126,42 @@ public class LookupExtractionFnTest
 
     final LookupExtractionFn lookupExtractionFn2 = OBJECT_MAPPER.readValue(str1, LookupExtractionFn.class);
 
-    Assert.assertEquals(retainMissing, lookupExtractionFn2.isRetainMissingValue());
-    Assert.assertEquals(replaceMissing, lookupExtractionFn2.getReplaceMissingValueWith());
+    Assertions.assertEquals(retainMissing, lookupExtractionFn2.isRetainMissingValue());
+    Assertions.assertEquals(replaceMissing, lookupExtractionFn2.getReplaceMissingValueWith());
 
     if (injective == null) {
-      Assert.assertEquals(lookupExtractionFn2.getLookup().isOneToOne(), lookupExtractionFn2.isInjective());
+      Assertions.assertEquals(lookupExtractionFn2.getLookup().isOneToOne(), lookupExtractionFn2.isInjective());
     } else {
-      Assert.assertEquals(injective, lookupExtractionFn2.isInjective());
+      Assertions.assertEquals(injective, lookupExtractionFn2.isInjective());
     }
 
-    Assert.assertArrayEquals(lookupExtractionFn.getCacheKey(), lookupExtractionFn2.getCacheKey());
+    Assertions.assertArrayEquals(lookupExtractionFn.getCacheKey(), lookupExtractionFn2.getCacheKey());
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         str1,
         OBJECT_MAPPER.writeValueAsString(lookupExtractionFn2)
     );
   }
 
-  @Test(expected = IllegalArgumentException.class)
+  @Test
   public void testIllegalArgs()
   {
-    if (retainMissing && replaceMissing != null) {
-      @SuppressWarnings("unused") // expected exception
-      final LookupExtractionFn lookupExtractionFn = new LookupExtractionFn(
-          new MapLookupExtractor(ImmutableMap.of("foo", "bar"), false),
-          retainMissing,
-          replaceMissing,
-          injective,
-          false
-      );
-    } else {
-      throw new IAE("Case not valid");
-    }
+    Assertions.assertThrows(
+        IllegalArgumentException.class,
+        () -> {
+          if (retainMissing && replaceMissing != null) {
+            new LookupExtractionFn(
+                new MapLookupExtractor(ImmutableMap.of("foo", "bar"), false),
+                retainMissing,
+                replaceMissing,
+                injective,
+                false
+            );
+          } else {
+            throw new IAE("Case not valid");
+          }
+        }
+    );
   }
 
   @Test
@@ -178,7 +183,7 @@ public class LookupExtractionFnTest
     );
 
     if (replaceMissing == null || retainMissing) {
-      Assert.assertFalse(
+      Assertions.assertFalse(
           Arrays.equals(
               lookupExtractionFn.getCacheKey(),
               new LookupExtractionFn(
@@ -190,7 +195,7 @@ public class LookupExtractionFnTest
               ).getCacheKey()
           )
       );
-      Assert.assertFalse(
+      Assertions.assertFalse(
           Arrays.equals(
               lookupExtractionFn.getCacheKey(),
               new LookupExtractionFn(
@@ -203,7 +208,7 @@ public class LookupExtractionFnTest
           )
       );
     }
-    Assert.assertFalse(
+    Assertions.assertFalse(
         Arrays.equals(
             lookupExtractionFn.getCacheKey(),
             new LookupExtractionFn(
@@ -215,7 +220,7 @@ public class LookupExtractionFnTest
             ).getCacheKey()
         )
     );
-    Assert.assertFalse(
+    Assertions.assertFalse(
         Arrays.equals(
             lookupExtractionFn.getCacheKey(),
             new LookupExtractionFn(
diff --git a/processing/src/test/java/org/apache/druid/query/metadata/SegmentAnalyzerTest.java b/processing/src/test/java/org/apache/druid/query/metadata/SegmentAnalyzerTest.java
index c5d2b34d234..57d3facf42c 100644
--- a/processing/src/test/java/org/apache/druid/query/metadata/SegmentAnalyzerTest.java
+++ b/processing/src/test/java/org/apache/druid/query/metadata/SegmentAnalyzerTest.java
@@ -72,14 +72,15 @@ import org.apache.druid.segment.serde.ComplexMetricExtractor;
 import org.apache.druid.segment.serde.ComplexMetricSerde;
 import org.apache.druid.segment.serde.ComplexMetrics;
 import org.apache.druid.testing.InitializedNullHandlingTest;
+import org.apache.druid.testing.TemporaryFolderExtension;
 import org.apache.druid.timeline.SegmentId;
 import org.easymock.EasyMock;
-import org.junit.Assert;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
 
 import javax.annotation.Nullable;
+
 import java.io.File;
 import java.io.IOException;
 import java.nio.ByteBuffer;
@@ -95,8 +96,8 @@ public class SegmentAnalyzerTest extends InitializedNullHandlingTest
   private static final EnumSet<SegmentMetadataQuery.AnalysisType> EMPTY_ANALYSES =
       EnumSet.noneOf(SegmentMetadataQuery.AnalysisType.class);
 
-  @Rule
-  public final TemporaryFolder temporaryFolder = new TemporaryFolder();
+  @RegisterExtension
+  public final TemporaryFolderExtension temporaryFolder = new TemporaryFolderExtension();
 
   @Test
   public void testIncrementalWorks()
@@ -112,14 +113,14 @@ public class SegmentAnalyzerTest extends InitializedNullHandlingTest
         analyses
     );
 
-    Assert.assertEquals(1, results.size());
+    Assertions.assertEquals(1, results.size());
 
     final SegmentAnalysis analysis = results.get(0);
-    Assert.assertEquals(SegmentId.dummy("ds").toString(), analysis.getId());
+    Assertions.assertEquals(SegmentId.dummy("ds").toString(), analysis.getId());
 
     final Map<String, ColumnAnalysis> columns = analysis.getColumns();
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         TestIndex.COLUMNS.length + 3,
         columns.size()
     ); // All columns including time and empty/null column
@@ -128,43 +129,55 @@ public class SegmentAnalyzerTest extends InitializedNullHandlingTest
     // This helps DruidSchema keep things in the proper order when it does SegmentMetadata queries.
     final List<Map.Entry<String, ColumnAnalysis>> entriesInOrder = new ArrayList<>(columns.entrySet());
 
-    Assert.assertEquals(ColumnHolder.TIME_COLUMN_NAME, entriesInOrder.get(0).getKey());
-    Assert.assertEquals(ColumnType.LONG, entriesInOrder.get(0).getValue().getTypeSignature());
+    Assertions.assertEquals(ColumnHolder.TIME_COLUMN_NAME, entriesInOrder.get(0).getKey());
+    Assertions.assertEquals(ColumnType.LONG, entriesInOrder.get(0).getValue().getTypeSignature());
 
     // Start from 1: skipping __time
     for (int i = 0; i < TestIndex.DIMENSION_SCHEMAS.size(); i++) {
       final DimensionSchema schema = TestIndex.DIMENSION_SCHEMAS.get(i);
       final Map.Entry<String, ColumnAnalysis> analysisEntry = entriesInOrder.get(i + 1 /* skip __time */);
       final String dimension = schema.getName();
-      Assert.assertEquals(dimension, analysisEntry.getKey());
+      Assertions.assertEquals(dimension, analysisEntry.getKey());
       final ColumnAnalysis columnAnalysis = analysisEntry.getValue();
       final boolean isString = schema.getColumnType().is(ValueType.STRING);
 
-      Assert.assertEquals(dimension, schema.getColumnType().toString(), columnAnalysis.getType());
-      Assert.assertEquals(dimension, 0, columnAnalysis.getSize());
+      Assertions.assertEquals(
+          schema.getColumnType().toString(),
+          columnAnalysis.getTypeSignature().asTypeString(),
+          dimension
+      );
+      Assertions.assertEquals(0, columnAnalysis.getSize(), dimension);
       if (isString) {
         if (analyses == null) {
-          Assert.assertTrue(dimension, columnAnalysis.getCardinality() > 0);
+          Assertions.assertTrue(columnAnalysis.getCardinality() > 0, dimension);
         } else {
-          Assert.assertEquals(dimension, 0, columnAnalysis.getCardinality().longValue());
+          Assertions.assertEquals(0, columnAnalysis.getCardinality().longValue(), dimension);
         }
       } else {
-        Assert.assertNull(dimension, columnAnalysis.getCardinality());
+        Assertions.assertNull(columnAnalysis.getCardinality(), dimension);
       }
     }
 
     for (String metric : TestIndex.DOUBLE_METRICS) {
       final ColumnAnalysis columnAnalysis = columns.get(metric);
-      Assert.assertEquals(metric, ValueType.DOUBLE.name(), columnAnalysis.getType());
-      Assert.assertEquals(metric, 0, columnAnalysis.getSize());
-      Assert.assertNull(metric, columnAnalysis.getCardinality());
+      Assertions.assertEquals(
+          ValueType.DOUBLE.name(),
+          columnAnalysis.getTypeSignature().asTypeString(),
+          metric
+      );
+      Assertions.assertEquals(0, columnAnalysis.getSize(), metric);
+      Assertions.assertNull(columnAnalysis.getCardinality(), metric);
     }
 
     for (String metric : TestIndex.FLOAT_METRICS) {
       final ColumnAnalysis columnAnalysis = columns.get(metric);
-      Assert.assertEquals(metric, ValueType.FLOAT.name(), columnAnalysis.getType());
-      Assert.assertEquals(metric, 0, columnAnalysis.getSize());
-      Assert.assertNull(metric, columnAnalysis.getCardinality());
+      Assertions.assertEquals(
+          ValueType.FLOAT.name(),
+          columnAnalysis.getTypeSignature().asTypeString(),
+          metric
+      );
+      Assertions.assertEquals(0, columnAnalysis.getSize(), metric);
+      Assertions.assertNull(columnAnalysis.getCardinality(), metric);
     }
   }
 
@@ -182,54 +195,66 @@ public class SegmentAnalyzerTest extends InitializedNullHandlingTest
         analyses
     );
 
-    Assert.assertEquals(1, results.size());
+    Assertions.assertEquals(1, results.size());
 
     final SegmentAnalysis analysis = results.get(0);
-    Assert.assertEquals(SegmentId.dummy("test_1").toString(), analysis.getId());
+    Assertions.assertEquals(SegmentId.dummy("test_1").toString(), analysis.getId());
 
     final Map<String, ColumnAnalysis> columns = analysis.getColumns();
     // Verify key order is the same as the underlying segment.
     // This helps DruidSchema keep things in the proper order when it does SegmentMetadata queries.
     final List<Map.Entry<String, ColumnAnalysis>> entriesInOrder = new ArrayList<>(columns.entrySet());
 
-    Assert.assertEquals(ColumnHolder.TIME_COLUMN_NAME, entriesInOrder.get(0).getKey());
-    Assert.assertEquals(ColumnType.LONG, entriesInOrder.get(0).getValue().getTypeSignature());
+    Assertions.assertEquals(ColumnHolder.TIME_COLUMN_NAME, entriesInOrder.get(0).getKey());
+    Assertions.assertEquals(ColumnType.LONG, entriesInOrder.get(0).getValue().getTypeSignature());
 
     // Start from 1: skipping __time
     for (int i = 0; i < TestIndex.DIMENSION_SCHEMAS.size(); i++) {
       final DimensionSchema schema = TestIndex.DIMENSION_SCHEMAS.get(i);
       final Map.Entry<String, ColumnAnalysis> analysisEntry = entriesInOrder.get(i + 1 /* skip __time */);
       final String dimension = schema.getName();
-      Assert.assertEquals(dimension, analysisEntry.getKey());
+      Assertions.assertEquals(dimension, analysisEntry.getKey());
       final ColumnAnalysis columnAnalysis = analysisEntry.getValue();
       final boolean isString = schema.getColumnType().is(ValueType.STRING);
-      Assert.assertEquals(dimension, schema.getColumnType().toString(), columnAnalysis.getType());
-      Assert.assertEquals(dimension, 0, columnAnalysis.getSize());
+      Assertions.assertEquals(
+          schema.getColumnType().toString(),
+          columnAnalysis.getTypeSignature().asTypeString(),
+          dimension
+      );
+      Assertions.assertEquals(0, columnAnalysis.getSize(), dimension);
 
       if (isString) {
         if (analyses == null) {
-          Assert.assertTrue(dimension, columnAnalysis.getCardinality() > 0);
+          Assertions.assertTrue(columnAnalysis.getCardinality() > 0, dimension);
         } else {
-          Assert.assertEquals(dimension, 0, columnAnalysis.getCardinality().longValue());
+          Assertions.assertEquals(0, columnAnalysis.getCardinality().longValue(), dimension);
         }
       } else {
-        Assert.assertNull(dimension, columnAnalysis.getCardinality());
+        Assertions.assertNull(columnAnalysis.getCardinality(), dimension);
       }
     }
 
     for (String metric : TestIndex.DOUBLE_METRICS) {
       final ColumnAnalysis columnAnalysis = columns.get(metric);
 
-      Assert.assertEquals(metric, ValueType.DOUBLE.name(), columnAnalysis.getType());
-      Assert.assertEquals(metric, 0, columnAnalysis.getSize());
-      Assert.assertNull(metric, columnAnalysis.getCardinality());
+      Assertions.assertEquals(
+          ValueType.DOUBLE.name(),
+          columnAnalysis.getTypeSignature().asTypeString(),
+          metric
+      );
+      Assertions.assertEquals(0, columnAnalysis.getSize(), metric);
+      Assertions.assertNull(columnAnalysis.getCardinality(), metric);
     }
 
     for (String metric : TestIndex.FLOAT_METRICS) {
       final ColumnAnalysis columnAnalysis = columns.get(metric);
-      Assert.assertEquals(metric, ValueType.FLOAT.name(), columnAnalysis.getType());
-      Assert.assertEquals(metric, 0, columnAnalysis.getSize());
-      Assert.assertNull(metric, columnAnalysis.getCardinality());
+      Assertions.assertEquals(
+          ValueType.FLOAT.name(),
+          columnAnalysis.getTypeSignature().asTypeString(),
+          metric
+      );
+      Assertions.assertEquals(0, columnAnalysis.getSize(), metric);
+      Assertions.assertNull(columnAnalysis.getCardinality(), metric);
     }
   }
 
@@ -331,9 +356,12 @@ public class SegmentAnalyzerTest extends InitializedNullHandlingTest
       IncrementalIndexSegment segment = new IncrementalIndexSegment(incrementalIndex, SegmentId.dummy("ds"));
       Map<String, ColumnAnalysis> analyses = analyzer.analyze(segment);
       ColumnAnalysis columnAnalysis = analyses.get(invalid_aggregator);
-      Assert.assertFalse(columnAnalysis.isError());
-      Assert.assertEquals("invalid_complex_column_type", columnAnalysis.getType());
-      Assert.assertEquals(ColumnType.ofComplex("invalid_complex_column_type"), columnAnalysis.getTypeSignature());
+      Assertions.assertFalse(columnAnalysis.isError());
+      Assertions.assertEquals(
+          "invalid_complex_column_type",
+          columnAnalysis.getTypeSignature().getComplexTypeName()
+      );
+      Assertions.assertEquals(ColumnType.ofComplex("invalid_complex_column_type"), columnAnalysis.getTypeSignature());
     }
 
     // Persist the index.
@@ -354,8 +382,8 @@ public class SegmentAnalyzerTest extends InitializedNullHandlingTest
       );
       Map<String, ColumnAnalysis> analyses = analyzer.analyze(segment);
       ColumnAnalysis invalidColumnAnalysis = analyses.get(invalid_aggregator);
-      Assert.assertTrue(invalidColumnAnalysis.isError());
-      Assert.assertEquals("error:unknown_complex_invalid_complex_column_type", invalidColumnAnalysis.getErrorMessage());
+      Assertions.assertTrue(invalidColumnAnalysis.isError());
+      Assertions.assertEquals("error:unknown_complex_invalid_complex_column_type", invalidColumnAnalysis.getErrorMessage());
 
       // Run a segment metadata query also to verify it doesn't break
       final List<SegmentAnalysis> results = getSegmentAnalysises(
@@ -363,7 +391,7 @@ public class SegmentAnalyzerTest extends InitializedNullHandlingTest
           EnumSet.of(SegmentMetadataQuery.AnalysisType.SIZE)
       );
       for (SegmentAnalysis result : results) {
-        Assert.assertTrue(result.getColumns().get(invalid_aggregator).isError());
+        Assertions.assertTrue(result.getColumns().get(invalid_aggregator).isError());
       }
     }
   }
@@ -392,8 +420,8 @@ public class SegmentAnalyzerTest extends InitializedNullHandlingTest
 
     SegmentAnalyzer analyzer = new SegmentAnalyzer(EMPTY_ANALYSES);
     Map<String, ColumnAnalysis> analysis = analyzer.analyze(s);
-    Assert.assertEquals(ColumnType.STRING, analysis.get("x").getTypeSignature());
-    Assert.assertFalse(analysis.get("x").isError());
+    Assertions.assertEquals(ColumnType.STRING, analysis.get("x").getTypeSignature());
+    Assertions.assertFalse(analysis.get("x").isError());
   }
 
   @Test
@@ -420,8 +448,8 @@ public class SegmentAnalyzerTest extends InitializedNullHandlingTest
 
     SegmentAnalyzer analyzer = new SegmentAnalyzer(EMPTY_ANALYSES);
     Map<String, ColumnAnalysis> analysis = analyzer.analyze(s);
-    Assert.assertEquals(ColumnType.STRING, analysis.get("x").getTypeSignature());
-    Assert.assertFalse(analysis.get("x").isError());
+    Assertions.assertEquals(ColumnType.STRING, analysis.get("x").getTypeSignature());
+    Assertions.assertFalse(analysis.get("x").isError());
   }
 
   @Test
@@ -444,11 +472,11 @@ public class SegmentAnalyzerTest extends InitializedNullHandlingTest
     final Map<String, ColumnAnalysis> analysis = analyzer.analyze(segment);
 
     // Clustering column (constant per group) + non-clustering dim + __time all present with right types.
-    Assert.assertEquals(ColumnType.STRING, analysis.get("tenant").getTypeSignature());
-    Assert.assertFalse("tenant should not be an error", analysis.get("tenant").isError());
-    Assert.assertEquals(ColumnType.STRING, analysis.get("region").getTypeSignature());
-    Assert.assertFalse("region should not be an error", analysis.get("region").isError());
-    Assert.assertEquals(ColumnType.LONG, analysis.get(ColumnHolder.TIME_COLUMN_NAME).getTypeSignature());
+    Assertions.assertEquals(ColumnType.STRING, analysis.get("tenant").getTypeSignature());
+    Assertions.assertFalse(analysis.get("tenant").isError(), "tenant should not be an error");
+    Assertions.assertEquals(ColumnType.STRING, analysis.get("region").getTypeSignature());
+    Assertions.assertFalse(analysis.get("region").isError(), "region should not be an error");
+    Assertions.assertEquals(ColumnType.LONG, analysis.get(ColumnHolder.TIME_COLUMN_NAME).getTypeSignature());
   }
 
   private QueryableIndex buildClusteredSegment() throws IOException
@@ -524,9 +552,9 @@ public class SegmentAnalyzerTest extends InitializedNullHandlingTest
 
     SegmentAnalyzer analyzer = new SegmentAnalyzer(EMPTY_ANALYSES);
     Map<String, ColumnAnalysis> analysis = analyzer.analyze(s);
-    Assert.assertEquals(ColumnType.UNKNOWN_COMPLEX, analysis.get("x").getTypeSignature());
-    Assert.assertTrue(analysis.get("x").isError());
-    Assert.assertTrue(analysis.get("x").getErrorMessage().contains("is not a [org.apache.druid.segment.column.ComplexColumn]"));
+    Assertions.assertEquals(ColumnType.UNKNOWN_COMPLEX, analysis.get("x").getTypeSignature());
+    Assertions.assertTrue(analysis.get("x").isError());
+    Assertions.assertTrue(analysis.get("x").getErrorMessage().contains("is not a [org.apache.druid.segment.column.ComplexColumn]"));
 
     EasyMock.verify(mockIndex, holder, dictionaryEncodedColumn);
   }
diff --git a/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataQueryQueryToolChestTest.java b/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataQueryQueryToolChestTest.java
index df0005c6935..70964dd044d 100644
--- a/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataQueryQueryToolChestTest.java
+++ b/processing/src/test/java/org/apache/druid/query/metadata/SegmentMetadataQueryQueryToolChestTest.java
@@ -51,9 +51,9 @@ import org.apache.druid.timeline.SegmentId;
 import org.hamcrest.MatcherAssert;
 import org.joda.time.Interval;
 import org.joda.time.Period;
-import org.junit.Assert;
-import org.junit.Assume;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Assumptions;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.EnumSource;
 
@@ -115,7 +115,7 @@ public class SegmentMetadataQueryQueryToolChestTest
     // Test cache key generation
     byte[] expectedKey = {0x04, 0x09, 0x01, 0x0A, 0x00, 0x00, 0x00, 0x03, 0x00, 0x02, 0x04};
     byte[] actualKey = strategy.computeCacheKey(query);
-    Assert.assertArrayEquals(expectedKey, actualKey);
+    Assertions.assertArrayEquals(expectedKey, actualKey);
 
     SegmentAnalysis result = new SegmentAnalysis.Builder(TEST_SEGMENT_ID1)
         .interval(Intervals.of("2011-01-12T00:00:00.000Z/2011-04-15T00:00:00.001Z"))
@@ -147,7 +147,7 @@ public class SegmentMetadataQueryQueryToolChestTest
 
     SegmentAnalysis fromCacheResult = strategy.pullFromSegmentLevelCache().apply(fromCacheValue);
 
-    Assert.assertEquals(result, fromCacheResult);
+    Assertions.assertEquals(result, fromCacheResult);
   }
 
   @EnumSource(AggregatorMergeStrategy.class)
@@ -169,7 +169,7 @@ public class SegmentMetadataQueryQueryToolChestTest
         .aggregator("bar", new DoubleSumAggregatorFactory("bar", "bar"))
         .aggregator("baz", new DoubleSumAggregatorFactory("baz", "baz"))
         .build();
-    Assert.assertEquals(expected, mergeWithStrategy(analysis1, analysis2, aggregatorMergeStrategy));
+    Assertions.assertEquals(expected, mergeWithStrategy(analysis1, analysis2, aggregatorMergeStrategy));
   }
 
   @EnumSource(AggregatorMergeStrategy.class)
@@ -195,14 +195,14 @@ public class SegmentMetadataQueryQueryToolChestTest
         .aggregator("bar", new DoubleSumAggregatorFactory("bar", "bar"))
         .aggregator("baz", new DoubleSumAggregatorFactory("baz", "baz"))
         .build();
-    Assert.assertEquals(expected, mergeWithStrategy(analysis1, analysis2, aggregatorMergeStrategy));
+    Assertions.assertEquals(expected, mergeWithStrategy(analysis1, analysis2, aggregatorMergeStrategy));
   }
 
   @EnumSource(AggregatorMergeStrategy.class)
   @ParameterizedTest(name = "{index}: with AggregatorMergeStrategy {0}")
   public void testMergeAggregatorsOneNullStrict(AggregatorMergeStrategy aggregatorMergeStrategy)
   {
-    Assume.assumeTrue(aggregatorMergeStrategy == AggregatorMergeStrategy.STRICT);
+    Assumptions.assumeTrue(aggregatorMergeStrategy == AggregatorMergeStrategy.STRICT);
... 4563 lines suppressed ...


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