Skip to content

test: migrate extensions-contrib tests to JUnit 5 #19908

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Draft
FrankChen021 wants to merge 1 commit into
base: master
Choose a base branch
from
Draft

test: migrate extensions-contrib tests to JUnit 5 #19908

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
50 changes: 15 additions & 35 deletions extensions-contrib/compressed-bigdecimal/pom.xml
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -38,6 +38,21 @@
</properties>

<dependencies>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-params</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.apache.druid</groupId>
<artifactId>druid-processing</artifactId>
Expand All @@ -63,36 +78,6 @@
</dependency>

<!-- Tests -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-migrationsupport</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-params</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.apache.druid</groupId>
<artifactId>druid-processing</artifactId>
Expand Down Expand Up @@ -121,11 +106,6 @@
<type>test-jar</type>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.hamcrest</groupId>
<artifactId>hamcrest</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
Expand Down
159 changes: 85 additions & 74 deletions ...al/src/test/java/org/apache/druid/compressedbigdecimal/ArrayCompressedBigDecimalTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -21,17 +21,18 @@

import org.apache.druid.compressedbigdecimal.aggregator.CompressedBigDecimalAggregatorFactoryBase;
import org.apache.druid.java.util.common.IAE;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.nio.ByteBuffer;

import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertSame;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertThrows;

/**
* Unit tests for CompressedBigDecimal.
Expand Down Expand Up @@ -171,35 +172,37 @@ public void testCompareToOptimization()
d3.accumulateSum(Utils.scale(new ArrayCompressedBigDecimal(new BigDecimal(8L * Integer.MAX_VALUE)), d3.getScale()));
d4.accumulateSum(Utils.scale(new ArrayCompressedBigDecimal(new BigDecimal(8L * Integer.MAX_VALUE)), d4.getScale()));

Assert.assertEquals(-1, d2.compareTo(d1, true));
Assert.assertEquals(1, d1.compareTo(d2, true));
Assert.assertEquals(0, d3.compareTo(d4, true));
Assert.assertEquals(0, d4.compareTo(d3, true));
Assert.assertEquals(-1, d1.compareTo
Assertions.assertEquals(-1, d2.compareTo(d1, true));
Assertions.assertEquals(1, d1.compareTo(d2, true));
Assertions.assertEquals(0, d3.compareTo(d4, true));
Assertions.assertEquals(0, d4.compareTo(d3, true));
Assertions.assertEquals(-1, d1.compareTo
(d3, true));
Assert.assertEquals(1, d3.compareTo(d1, true));
Assert.assertEquals(-1, d2.compareTo(d3, true));
Assert.assertEquals(1, d3.compareTo(d2, true));
Assert.assertEquals(1, d5.compareTo(d2, true));
Assert.assertEquals(-1, d2.compareTo(d5, true));
Assert.assertEquals(-1, d5.compareTo(d3, true));
Assert.assertEquals(1, d3.compareTo(d5, true));
Assertions.assertEquals(1, d3.compareTo(d1, true));
Assertions.assertEquals(-1, d2.compareTo(d3, true));
Assertions.assertEquals(1, d3.compareTo(d2, true));
Assertions.assertEquals(1, d5.compareTo(d2, true));
Assertions.assertEquals(-1, d2.compareTo(d5, true));
Assertions.assertEquals(-1, d5.compareTo(d3, true));
Assertions.assertEquals(1, d3.compareTo(d5, true));
}

@Test(expected = IAE.class)
@Test
public void testCompareToFailOptimized()
{
ArrayCompressedBigDecimal d1 = ArrayCompressedBigDecimal.allocateZero(
CompressedBigDecimalAggregatorFactoryBase.DEFAULT_SIZE,
CompressedBigDecimalAggregatorFactoryBase.DEFAULT_SCALE
);
ArrayCompressedBigDecimal d2 = ArrayCompressedBigDecimal.allocateZero(
CompressedBigDecimalAggregatorFactoryBase.DEFAULT_SIZE,
CompressedBigDecimalAggregatorFactoryBase.DEFAULT_SCALE + 1
);
assertThrows(IAE.class, () -> {
ArrayCompressedBigDecimal d1 = ArrayCompressedBigDecimal.allocateZero(
CompressedBigDecimalAggregatorFactoryBase.DEFAULT_SIZE,
CompressedBigDecimalAggregatorFactoryBase.DEFAULT_SCALE
);
ArrayCompressedBigDecimal d2 = ArrayCompressedBigDecimal.allocateZero(
CompressedBigDecimalAggregatorFactoryBase.DEFAULT_SIZE,
CompressedBigDecimalAggregatorFactoryBase.DEFAULT_SCALE + 1
);

// size doesn't match, so an IAE will be thrown
d1.compareTo(d2, true);
// size doesn't match, so an IAE will be thrown
d1.compareTo(d2, true);
});
}

@Test
Expand Down Expand Up @@ -232,18 +235,18 @@ public void testCompareToOptimizedUnequalSizes()
d3.accumulateSum(Utils.scale(new ArrayCompressedBigDecimal(new BigDecimal(8L * Integer.MAX_VALUE)), d3.getScale()));
d4.accumulateSum(Utils.scale(new ArrayCompressedBigDecimal(new BigDecimal(8L * Integer.MAX_VALUE)), d4.getScale()));

Assert.assertEquals(-1, d2.compareTo(d1, true));
Assert.assertEquals(1, d1.compareTo(d2, true));
Assert.assertEquals(0, d3.compareTo(d4, true));
Assert.assertEquals(0, d4.compareTo(d3, true));
Assert.assertEquals(-1, d1.compareTo(d3, true));
Assert.assertEquals(1, d3.compareTo(d1, true));
Assert.assertEquals(-1, d2.compareTo(d3, true));
Assert.assertEquals(1, d3.compareTo(d2, true));
Assert.assertEquals(1, d5.compareTo(d2, true));
Assert.assertEquals(-1, d2.compareTo(d5, true));
Assert.assertEquals(-1, d5.compareTo(d3, true));
Assert.assertEquals(1, d3.compareTo(d5, true));
Assertions.assertEquals(-1, d2.compareTo(d1, true));
Assertions.assertEquals(1, d1.compareTo(d2, true));
Assertions.assertEquals(0, d3.compareTo(d4, true));
Assertions.assertEquals(0, d4.compareTo(d3, true));
Assertions.assertEquals(-1, d1.compareTo(d3, true));
Assertions.assertEquals(1, d3.compareTo(d1, true));
Assertions.assertEquals(-1, d2.compareTo(d3, true));
Assertions.assertEquals(1, d3.compareTo(d2, true));
Assertions.assertEquals(1, d5.compareTo(d2, true));
Assertions.assertEquals(-1, d2.compareTo(d5, true));
Assertions.assertEquals(-1, d5.compareTo(d3, true));
Assertions.assertEquals(1, d3.compareTo(d5, true));
}

@Test
Expand All @@ -255,10 +258,10 @@ public void testCompareToOverflow()
CompressedBigDecimal negativeOne = ArrayCompressedBigDecimal.wrap(new int[]{-1, -1}, 0);

// compareTo skips subtraction in overflow cases
Assert.assertEquals(1, maxPositive.compareTo(minNegative));
Assert.assertEquals(-1, minNegative.compareTo(maxPositive));
Assert.assertEquals(1, maxPositive.compareTo(negativeOne));
Assert.assertEquals(-1, minNegative.compareTo(one));
Assertions.assertEquals(1, maxPositive.compareTo(minNegative));
Assertions.assertEquals(-1, minNegative.compareTo(maxPositive));
Assertions.assertEquals(1, maxPositive.compareTo(negativeOne));
Assertions.assertEquals(-1, minNegative.compareTo(one));
}

/**
Expand Down Expand Up @@ -438,25 +441,29 @@ public void testUnevenAccumulateOverflow()
/**
* Test method for {@link ArrayCompressedBigDecimal#accumulateSum(CompressedBigDecimal)}.
*/
@Test(expected = IllegalArgumentException.class)
@Test
public void testUnevenAccumulateOverflowWithTruncate()
{
ArrayCompressedBigDecimal bd = ArrayCompressedBigDecimal.wrap(new int[]{Integer.MAX_VALUE}, 0);
assertThrows(IllegalArgumentException.class, () -> {
ArrayCompressedBigDecimal bd = ArrayCompressedBigDecimal.wrap(new int[]{Integer.MAX_VALUE}, 0);

ArrayCompressedBigDecimal add = ArrayCompressedBigDecimal.wrap(new int[]{1, 1}, 0);
ArrayCompressedBigDecimal add = ArrayCompressedBigDecimal.wrap(new int[]{1, 1}, 0);

bd.accumulateSum(add);
bd.accumulateSum(add);
});
}

/**
* Test method for {@link ArrayCompressedBigDecimal#accumulateSum(CompressedBigDecimal)}.
*/
@Test(expected = IllegalArgumentException.class)
@Test
public void testAccumulateSumScaleMismatch()
{
ArrayCompressedBigDecimal bd = ArrayCompressedBigDecimal.allocateZero(2, 1);
ArrayCompressedBigDecimal add = new ArrayCompressedBigDecimal(1, 0);
bd.accumulateSum(add);
assertThrows(IllegalArgumentException.class, () -> {
ArrayCompressedBigDecimal bd = ArrayCompressedBigDecimal.allocateZero(2, 1);
ArrayCompressedBigDecimal add = new ArrayCompressedBigDecimal(1, 0);
bd.accumulateSum(add);
});
}

/**
Expand Down Expand Up @@ -524,22 +531,26 @@ public void testCopyToBuffer()
/**
* Test method for {@link Utils#accumulateSum(ByteBuffer, int, int, int, CompressedBigDecimal)}
*/
@Test(expected = IllegalArgumentException.class)
@Test
public void testUtilsAccumulateSumByteBuf()
{
ByteBuffer buf = ByteBuffer.allocate(4);
Utils.accumulateSum(buf, 0, 1, 2, new ArrayCompressedBigDecimal(new BigDecimal(Long.MAX_VALUE)));
assertThrows(IllegalArgumentException.class, () -> {
ByteBuffer buf = ByteBuffer.allocate(4);
Utils.accumulateSum(buf, 0, 1, 2, new ArrayCompressedBigDecimal(new BigDecimal(Long.MAX_VALUE)));
});
}

/**
* Test method for {@link Utils#accumulateSum(CompressedBigDecimal, long, int)}
*/
@Test(expected = IllegalArgumentException.class)
@Test
public void testUtilsAccumulateSumCbdWithExeception()
{
BigDecimal bd = new BigDecimal(new BigInteger("1"));
ArrayCompressedBigDecimal d = new ArrayCompressedBigDecimal(bd);
Utils.accumulateSum(d, 0L, 1);
assertThrows(IllegalArgumentException.class, () -> {
BigDecimal bd = new BigDecimal(new BigInteger("1"));
ArrayCompressedBigDecimal d = new ArrayCompressedBigDecimal(bd);
Utils.accumulateSum(d, 0L, 1);
});
}

/**
Expand All @@ -565,7 +576,7 @@ public void testScaleDown()
{
CompressedBigDecimal bd = new ArrayCompressedBigDecimal(new BigDecimal("1.1234567890"));
CompressedBigDecimal scaled = Utils.scale(bd, 9);
Assert.assertEquals("1.123456789", scaled.toString());
Assertions.assertEquals("1.123456789", scaled.toString());
}

/**
Expand Down Expand Up @@ -595,7 +606,7 @@ public void testSetMinValue()
ArrayCompressedBigDecimal bd = ArrayCompressedBigDecimal.allocateZero(2, 0);

bd.setMinValue();
Assert.assertEquals("-9223372036854775808", bd.toString());
Assertions.assertEquals("-9223372036854775808", bd.toString());
}

@Test
Expand All @@ -604,7 +615,7 @@ public void testSetMaxValue()
ArrayCompressedBigDecimal bd = ArrayCompressedBigDecimal.allocateZero(2, 0);

bd.setMaxValue();
Assert.assertEquals("9223372036854775807", bd.toString());
Assertions.assertEquals("9223372036854775807", bd.toString());
}

@Test
Expand All @@ -618,13 +629,13 @@ public void testAccumulateMaxInteger()
ArrayCompressedBigDecimal bd4 = new ArrayCompressedBigDecimal(new BigDecimal(Integer.MAX_VALUE));

bdBase.accumulateMax(bd1);
Assert.assertEquals(Long.toString(Long.MIN_VALUE), bdBase.toString());
Assertions.assertEquals(Long.toString(Long.MIN_VALUE), bdBase.toString());
bdBase.accumulateMax(bd2);
Assert.assertEquals("-1", bdBase.toString());
Assertions.assertEquals("-1", bdBase.toString());
bdBase.accumulateMax(bd3);
Assert.assertEquals(Long.toString(Long.MAX_VALUE), bdBase.toString());
Assertions.assertEquals(Long.toString(Long.MAX_VALUE), bdBase.toString());
bdBase.accumulateMax(bd4);
Assert.assertEquals(Long.toString(Long.MAX_VALUE), bdBase.toString());
Assertions.assertEquals(Long.toString(Long.MAX_VALUE), bdBase.toString());
}

@Test
Expand All @@ -642,20 +653,20 @@ public void testAccumulateMinInteger()
ArrayCompressedBigDecimal bd7 = ArrayCompressedBigDecimal.wrap(new int[]{0, 0, 0, 0, 0, 1}, 0);

bdBase.accumulateMin(bd1);
Assert.assertEquals("-1", bdBase.toString());
Assertions.assertEquals("-1", bdBase.toString());
bdBase.accumulateMin(bd2);
Assert.assertEquals("-1", bdBase.toString());
Assertions.assertEquals("-1", bdBase.toString());
bdBase.accumulateMin(bd3);
Assert.assertEquals("-1", bdBase.toString());
Assertions.assertEquals("-1", bdBase.toString());
bdBase.accumulateMin(bd4);
Assert.assertEquals(Integer.toString(Integer.MIN_VALUE), bdBase.toString());
Assertions.assertEquals(Integer.toString(Integer.MIN_VALUE), bdBase.toString());
bdBase.accumulateMin(bd5);
Assert.assertEquals(Long.toString(Long.MIN_VALUE), bdBase.toString());
Assertions.assertEquals(Long.toString(Long.MIN_VALUE), bdBase.toString());
// smallest possible 6-int[] number
bdBase.accumulateMin(bd6);
Assert.assertEquals("-3138550867693340381917894711603833208051177722232017256448", bdBase.toString());
Assertions.assertEquals("-3138550867693340381917894711603833208051177722232017256448", bdBase.toString());
// this tests that we don't do the subtraction and overflow
bdBase.accumulateMin(bd7);
Assert.assertEquals("-3138550867693340381917894711603833208051177722232017256448", bdBase.toString());
Assertions.assertEquals("-3138550867693340381917894711603833208051177722232017256448", bdBase.toString());
}
}
6 changes: 3 additions & 3 deletions ...c/test/java/org/apache/druid/compressedbigdecimal/ByteBufferCompressedBigDecimalTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -19,8 +19,8 @@

package org.apache.druid.compressedbigdecimal;

import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

import java.math.BigDecimal;
import java.nio.ByteBuffer;
Expand Down Expand Up @@ -83,6 +83,6 @@ public void testBufferValue(String expectedValue)
SCALE
);

Assert.assertEquals(expectedValue, compressedBigDecimal.toString());
Assertions.assertEquals(expectedValue, compressedBigDecimal.toString());
}
}
6 changes: 3 additions & 3 deletions .../src/test/java/org/apache/druid/compressedbigdecimal/CompressedBigDecimalCachingTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -23,8 +23,8 @@
import org.apache.druid.compressedbigdecimal.aggregator.min.CompressedBigDecimalMinAggregatorFactory;
import org.apache.druid.compressedbigdecimal.aggregator.sum.CompressedBigDecimalSumAggregatorFactory;
import org.apache.druid.query.aggregation.AggregatorFactory;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

import java.util.Base64;
import java.util.HashMap;
Expand Down Expand Up @@ -70,6 +70,6 @@ public void testCrossFactory()
cache.put(Base64.getEncoder().encodeToString(aggregatorFactory2.getCacheKey()), FLAG);
cache.put(Base64.getEncoder().encodeToString(aggregatorFactory3.getCacheKey()), FLAG);

Assert.assertEquals(3, cache.size());
Assertions.assertEquals(3, cache.size());
}
}
Loading
Loading