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