You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by ah...@apache.org on 2020/06/29 15:28:38 UTC
[commons-numbers] branch master updated (9bc3804 -> ebbbf92)
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git.
from 9bc3804 Update commons-parent 50 to 51
new c83453e Fix SonarCloud: Test scope for JUnit5 can be package-private
new 7983d34 Add assertions to test of useless cache
new 7ab58cc Fix SonarCloud: Remove nested ternary
new 4077b9a Fix SonarCloud: Use assertNotEquals
new d1b9542 Remove commented out code
new eb5a13e Use assertThrows instead of catching an expected exception
new 7b57fc8 Use assertTrue/False when testing the equals method
new ebbbf92 Use assertThrows
The 8 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../numbers/angle/PlaneAngleRadiansTest.java | 30 +--
.../commons/numbers/angle/PlaneAngleTest.java | 30 +--
.../commons/numbers/arrays/CosAngleTest.java | 8 +-
.../numbers/arrays/LinearCombinationTest.java | 10 +-
.../arrays/MultidimensionalCounterTest.java | 10 +-
.../commons/numbers/arrays/SafeNormTest.java | 14 +-
.../numbers/combinatorics/FactorialDouble.java | 11 +-
.../numbers/combinatorics/LogFactorial.java | 11 +-
.../BinomialCoefficientDoubleTest.java | 12 +-
.../combinatorics/BinomialCoefficientTest.java | 20 +-
.../numbers/combinatorics/CombinationsTest.java | 32 +--
.../numbers/combinatorics/FactorialDoubleTest.java | 30 +--
.../numbers/combinatorics/FactorialTest.java | 8 +-
.../combinatorics/LogBinomialCoefficientTest.java | 10 +-
.../numbers/combinatorics/LogFactorialTest.java | 31 +--
.../numbers/complex/streams/ComplexUtilsTest.java | 82 +++----
.../commons/numbers/complex/CReferenceTest.java | 26 +--
.../commons/numbers/complex/CStandardTest.java | 32 +--
.../numbers/complex/ComplexEdgeCaseTest.java | 22 +-
.../commons/numbers/complex/ComplexTest.java | 242 ++++++++++-----------
.../commons/numbers/core/ArithmeticUtilsTest.java | 62 +++---
.../apache/commons/numbers/core/PrecisionTest.java | 44 ++--
.../examples/jmh/arrays/DoublePrecisionTest.java | 10 +-
.../jmh/arrays/LinearCombinationsTest.java | 8 +-
.../org/apache/commons/numbers/field/FP64Test.java | 20 +-
.../commons/numbers/fraction/BigFractionTest.java | 74 +++----
.../numbers/fraction/ContinuedFractionTest.java | 14 +-
.../commons/numbers/fraction/FractionTest.java | 62 +++---
.../apache/commons/numbers/gamma/DigammaTest.java | 8 +-
.../commons/numbers/gamma/ErfDifferenceTest.java | 2 +-
.../org/apache/commons/numbers/gamma/ErfTest.java | 14 +-
.../org/apache/commons/numbers/gamma/ErfcTest.java | 4 +-
.../apache/commons/numbers/gamma/GammaTest.java | 6 +-
.../commons/numbers/gamma/InvGamma1pm1Test.java | 6 +-
.../commons/numbers/gamma/InverseErfTest.java | 6 +-
.../commons/numbers/gamma/InverseErfcTest.java | 6 +-
.../numbers/gamma/LanczosApproximationTest.java | 4 +-
.../apache/commons/numbers/gamma/LogBetaTest.java | 28 +--
.../commons/numbers/gamma/LogGamma1pTest.java | 6 +-
.../commons/numbers/gamma/LogGammaSumTest.java | 10 +-
.../apache/commons/numbers/gamma/LogGammaTest.java | 14 +-
.../commons/numbers/gamma/RegularizedBetaTest.java | 26 +--
.../numbers/gamma/RegularizedGammaTest.java | 20 +-
.../apache/commons/numbers/gamma/TrigammaTest.java | 4 +-
.../apache/commons/numbers/primes/PrimesTest.java | 6 +-
.../commons/numbers/primes/SmallPrimesTest.java | 30 +--
.../commons/numbers/quaternion/QuaternionTest.java | 110 +++++-----
.../commons/numbers/quaternion/SlerpTest.java | 22 +-
.../numbers/rootfinder/BrentSolverTest.java | 35 ++-
pom.xml | 1 -
50 files changed, 668 insertions(+), 665 deletions(-)
[commons-numbers] 03/08: Fix SonarCloud: Remove nested ternary
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit 7ab58cc1d403611d1869847260953d0302154acc
Author: aherbert <ah...@apache.org>
AuthorDate: Mon Jun 29 15:52:45 2020 +0100
Fix SonarCloud: Remove nested ternary
---
.../apache/commons/numbers/combinatorics/FactorialDouble.java | 11 ++++++++---
.../apache/commons/numbers/combinatorics/LogFactorial.java | 11 ++++++++---
2 files changed, 16 insertions(+), 6 deletions(-)
diff --git a/commons-numbers-combinatorics/src/main/java/org/apache/commons/numbers/combinatorics/FactorialDouble.java b/commons-numbers-combinatorics/src/main/java/org/apache/commons/numbers/combinatorics/FactorialDouble.java
index 32cd5d1..f3c34dc 100644
--- a/commons-numbers-combinatorics/src/main/java/org/apache/commons/numbers/combinatorics/FactorialDouble.java
+++ b/commons-numbers-combinatorics/src/main/java/org/apache/commons/numbers/combinatorics/FactorialDouble.java
@@ -54,9 +54,14 @@ public final class FactorialDouble {
}
final int beginCopy = 2;
- final int endCopy = cache == null || cache.length <= beginCopy ?
- beginCopy : cache.length <= numValues ?
- cache.length : numValues;
+ int endCopy;
+ if (cache == null || cache.length <= beginCopy) {
+ endCopy = beginCopy;
+ } else if (cache.length <= numValues) {
+ endCopy = cache.length;
+ } else {
+ endCopy = numValues;
+ }
// Copy available values.
for (int i = beginCopy; i < endCopy; i++) {
diff --git a/commons-numbers-combinatorics/src/main/java/org/apache/commons/numbers/combinatorics/LogFactorial.java b/commons-numbers-combinatorics/src/main/java/org/apache/commons/numbers/combinatorics/LogFactorial.java
index 00b6813..76af8a2 100644
--- a/commons-numbers-combinatorics/src/main/java/org/apache/commons/numbers/combinatorics/LogFactorial.java
+++ b/commons-numbers-combinatorics/src/main/java/org/apache/commons/numbers/combinatorics/LogFactorial.java
@@ -52,9 +52,14 @@ public final class LogFactorial {
logFactorials = new double[numValues];
final int beginCopy = 2;
- final int endCopy = cache == null || cache.length <= beginCopy ?
- beginCopy : cache.length <= numValues ?
- cache.length : numValues;
+ int endCopy;
+ if (cache == null || cache.length <= beginCopy) {
+ endCopy = beginCopy;
+ } else if (cache.length <= numValues) {
+ endCopy = cache.length;
+ } else {
+ endCopy = numValues;
+ }
// Copy available values.
for (int i = beginCopy; i < endCopy; i++) {
[commons-numbers] 06/08: Use assertThrows instead of catching an
expected exception
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit eb5a13e3c4b9ebe6de62f5a43ac60e291018529b
Author: aherbert <ah...@apache.org>
AuthorDate: Mon Jun 29 16:03:30 2020 +0100
Use assertThrows instead of catching an expected exception
---
.../commons/numbers/rootfinder/BrentSolverTest.java | 21 +++++++--------------
1 file changed, 7 insertions(+), 14 deletions(-)
diff --git a/commons-numbers-rootfinder/src/test/java/org/apache/commons/numbers/rootfinder/BrentSolverTest.java b/commons-numbers-rootfinder/src/test/java/org/apache/commons/numbers/rootfinder/BrentSolverTest.java
index aebd765..516aaef 100644
--- a/commons-numbers-rootfinder/src/test/java/org/apache/commons/numbers/rootfinder/BrentSolverTest.java
+++ b/commons-numbers-rootfinder/src/test/java/org/apache/commons/numbers/rootfinder/BrentSolverTest.java
@@ -146,24 +146,17 @@ public class BrentSolverTest {
DEFAULT_RELATIVE_ACCURACY,
DEFAULT_FUNCTION_ACCURACY);
- double result;
- MonitoredFunction f;
-
// Very large bracket around 1 for testing fast growth behavior.
- f = new MonitoredFunction(func);
- result = solver.findRoot(f, 0.85, 5);
+ final MonitoredFunction f = new MonitoredFunction(func);
+ final double result = solver.findRoot(f, 0.85, 5);
Assertions.assertEquals(1.0, result, DEFAULT_ABSOLUTE_ACCURACY);
Assertions.assertTrue(f.getCallsCount() <= 15);
- try {
- f = new MonitoredFunction(func, 10);
- result = solver.findRoot(f, 0.85, 5);
- Assertions.fail("Expected too many calls condition");
- } catch (IllegalStateException ex) {
- // Expected.
- // Ensure expected error condition.
- Assertions.assertNotEquals(-1, ex.getMessage().indexOf("too many calls"));
- }
+ final MonitoredFunction f2 = new MonitoredFunction(func, 10);
+ final IllegalArgumentException ex = Assertions.assertThrows(IllegalArgumentException.class,
+ () -> solver.findRoot(f2, 0.85, 5), "Expected too many calls condition");
+ // Ensure expected error condition.
+ Assertions.assertNotEquals(-1, ex.getMessage().indexOf("too many calls"));
}
@Test
[commons-numbers] 08/08: Use assertThrows
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit ebbbf929bd0745a1cd3f27e1092f9636439a7f92
Author: aherbert <ah...@apache.org>
AuthorDate: Mon Jun 29 16:18:29 2020 +0100
Use assertThrows
---
.../java/org/apache/commons/numbers/core/ArithmeticUtilsTest.java | 8 ++------
.../org/apache/commons/numbers/rootfinder/BrentSolverTest.java | 2 +-
2 files changed, 3 insertions(+), 7 deletions(-)
diff --git a/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/ArithmeticUtilsTest.java b/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/ArithmeticUtilsTest.java
index a86ae4c..dc9ef9b 100644
--- a/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/ArithmeticUtilsTest.java
+++ b/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/ArithmeticUtilsTest.java
@@ -304,12 +304,8 @@ public class ArithmeticUtilsTest {
Assertions.assertEquals(BigInteger.valueOf(1801088541L), ArithmeticUtils.pow(twentyOne, BigInteger.valueOf(7L)));
Assertions.assertEquals(BigInteger.ONE, ArithmeticUtils.pow(twentyOne, BigInteger.ZERO));
- try {
- ArithmeticUtils.pow(twentyOne, BigInteger.valueOf(-7L));
- Assertions.fail("Expecting IllegalArgumentException");
- } catch (IllegalArgumentException e) {
- // expected behavior
- }
+ Assertions.assertThrows(IllegalArgumentException.class, () ->
+ ArithmeticUtils.pow(twentyOne, BigInteger.valueOf(-7L)));
BigInteger bigOne =
new BigInteger("1543786922199448028351389769265814882661837148" +
diff --git a/commons-numbers-rootfinder/src/test/java/org/apache/commons/numbers/rootfinder/BrentSolverTest.java b/commons-numbers-rootfinder/src/test/java/org/apache/commons/numbers/rootfinder/BrentSolverTest.java
index 516aaef..40cf641 100644
--- a/commons-numbers-rootfinder/src/test/java/org/apache/commons/numbers/rootfinder/BrentSolverTest.java
+++ b/commons-numbers-rootfinder/src/test/java/org/apache/commons/numbers/rootfinder/BrentSolverTest.java
@@ -153,7 +153,7 @@ public class BrentSolverTest {
Assertions.assertTrue(f.getCallsCount() <= 15);
final MonitoredFunction f2 = new MonitoredFunction(func, 10);
- final IllegalArgumentException ex = Assertions.assertThrows(IllegalArgumentException.class,
+ final IllegalStateException ex = Assertions.assertThrows(IllegalStateException.class,
() -> solver.findRoot(f2, 0.85, 5), "Expected too many calls condition");
// Ensure expected error condition.
Assertions.assertNotEquals(-1, ex.getMessage().indexOf("too many calls"));
[commons-numbers] 01/08: Fix SonarCloud: Test scope for JUnit5 can
be package-private
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit c83453e4745f7942686790c043d42886ebc78d4c
Author: aherbert <ah...@apache.org>
AuthorDate: Mon Jun 29 15:41:52 2020 +0100
Fix SonarCloud: Test scope for JUnit5 can be package-private
---
.../numbers/angle/PlaneAngleRadiansTest.java | 30 +--
.../commons/numbers/angle/PlaneAngleTest.java | 30 +--
.../commons/numbers/arrays/CosAngleTest.java | 8 +-
.../numbers/arrays/LinearCombinationTest.java | 10 +-
.../arrays/MultidimensionalCounterTest.java | 10 +-
.../commons/numbers/arrays/SafeNormTest.java | 14 +-
.../BinomialCoefficientDoubleTest.java | 12 +-
.../combinatorics/BinomialCoefficientTest.java | 20 +-
.../numbers/combinatorics/CombinationsTest.java | 32 +--
.../numbers/combinatorics/FactorialDoubleTest.java | 24 +-
.../numbers/combinatorics/FactorialTest.java | 8 +-
.../combinatorics/LogBinomialCoefficientTest.java | 10 +-
.../numbers/combinatorics/LogFactorialTest.java | 18 +-
.../numbers/complex/streams/ComplexUtilsTest.java | 82 +++----
.../commons/numbers/complex/CReferenceTest.java | 26 +--
.../commons/numbers/complex/CStandardTest.java | 32 +--
.../numbers/complex/ComplexEdgeCaseTest.java | 22 +-
.../commons/numbers/complex/ComplexTest.java | 242 ++++++++++-----------
.../commons/numbers/core/ArithmeticUtilsTest.java | 54 ++---
.../apache/commons/numbers/core/PrecisionTest.java | 44 ++--
.../examples/jmh/arrays/DoublePrecisionTest.java | 10 +-
.../jmh/arrays/LinearCombinationsTest.java | 8 +-
.../org/apache/commons/numbers/field/FP64Test.java | 20 +-
.../commons/numbers/fraction/BigFractionTest.java | 72 +++---
.../numbers/fraction/ContinuedFractionTest.java | 14 +-
.../commons/numbers/fraction/FractionTest.java | 58 ++---
.../apache/commons/numbers/gamma/DigammaTest.java | 8 +-
.../commons/numbers/gamma/ErfDifferenceTest.java | 2 +-
.../org/apache/commons/numbers/gamma/ErfTest.java | 14 +-
.../org/apache/commons/numbers/gamma/ErfcTest.java | 4 +-
.../apache/commons/numbers/gamma/GammaTest.java | 6 +-
.../commons/numbers/gamma/InvGamma1pm1Test.java | 6 +-
.../commons/numbers/gamma/InverseErfTest.java | 6 +-
.../commons/numbers/gamma/InverseErfcTest.java | 6 +-
.../numbers/gamma/LanczosApproximationTest.java | 4 +-
.../apache/commons/numbers/gamma/LogBetaTest.java | 28 +--
.../commons/numbers/gamma/LogGamma1pTest.java | 6 +-
.../commons/numbers/gamma/LogGammaSumTest.java | 10 +-
.../apache/commons/numbers/gamma/LogGammaTest.java | 14 +-
.../commons/numbers/gamma/RegularizedBetaTest.java | 26 +--
.../numbers/gamma/RegularizedGammaTest.java | 20 +-
.../apache/commons/numbers/gamma/TrigammaTest.java | 4 +-
.../apache/commons/numbers/primes/PrimesTest.java | 6 +-
.../commons/numbers/primes/SmallPrimesTest.java | 30 +--
.../commons/numbers/quaternion/QuaternionTest.java | 102 ++++-----
.../commons/numbers/quaternion/SlerpTest.java | 22 +-
.../numbers/rootfinder/BrentSolverTest.java | 14 +-
47 files changed, 624 insertions(+), 624 deletions(-)
diff --git a/commons-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleRadiansTest.java b/commons-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleRadiansTest.java
index 79b62eb..e4484f3 100644
--- a/commons-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleRadiansTest.java
+++ b/commons-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleRadiansTest.java
@@ -25,7 +25,7 @@ import org.junit.jupiter.api.Test;
public class PlaneAngleRadiansTest {
@Test
@SuppressWarnings("squid:S3415")
- public void testConstants() {
+ void testConstants() {
final double eps = 0;
Assertions.assertEquals(Math.PI, PlaneAngleRadians.PI, eps);
@@ -36,7 +36,7 @@ public class PlaneAngleRadiansTest {
// Test constants using "sin" and "cos".
@Test
- public void testConstants2() {
+ void testConstants2() {
final double eps = Math.ulp(1d);
Assertions.assertEquals(0d, Math.sin(PlaneAngleRadians.PI), eps);
@@ -53,7 +53,7 @@ public class PlaneAngleRadiansTest {
}
@Test
- public void testNormalize() {
+ void testNormalize() {
for (double a = -15.0; a <= 15.0; a += 0.1) {
for (double b = -15.0; b <= 15.0; b += 0.2) {
final double c = PlaneAngleRadians.normalize(a, b);
@@ -66,7 +66,7 @@ public class PlaneAngleRadiansTest {
}
@Test
- public void testNormalizeBetweenMinusPiAndPi1() {
+ void testNormalizeBetweenMinusPiAndPi1() {
final double value = 1.25 * PlaneAngleRadians.TWO_PI;
final double expected = PlaneAngleRadians.PI_OVER_TWO;
final double actual = PlaneAngleRadians.normalizeBetweenMinusPiAndPi(value);
@@ -74,7 +74,7 @@ public class PlaneAngleRadiansTest {
Assertions.assertEquals(expected, actual, tol);
}
@Test
- public void testNormalizeBetweenMinusPiAndPi2() {
+ void testNormalizeBetweenMinusPiAndPi2() {
final double value = 0.75 * PlaneAngleRadians.TWO_PI;
final double expected = -PlaneAngleRadians.PI_OVER_TWO;
final double actual = PlaneAngleRadians.normalizeBetweenMinusPiAndPi(value);
@@ -82,7 +82,7 @@ public class PlaneAngleRadiansTest {
Assertions.assertEquals(expected, actual, tol);
}
@Test
- public void testNormalizeBetweenMinusPiAndPi3() {
+ void testNormalizeBetweenMinusPiAndPi3() {
final double value = PlaneAngleRadians.PI + 1e-10;
final double expected = -PlaneAngleRadians.PI + 1e-10;
final double actual = PlaneAngleRadians.normalizeBetweenMinusPiAndPi(value);
@@ -90,7 +90,7 @@ public class PlaneAngleRadiansTest {
Assertions.assertEquals(expected, actual, tol);
}
@Test
- public void testNormalizeBetweenMinusPiAndPi4() {
+ void testNormalizeBetweenMinusPiAndPi4() {
final double value = 5 * PlaneAngleRadians.PI / 4;
final double expected = PlaneAngleRadians.PI * (1d / 4 - 1);
final double actual = PlaneAngleRadians.normalizeBetweenMinusPiAndPi(value);
@@ -99,7 +99,7 @@ public class PlaneAngleRadiansTest {
}
@Test
- public void testNormalizeBetweenMinusPiAndPi_lowerBound() {
+ void testNormalizeBetweenMinusPiAndPi_lowerBound() {
final double value = PlaneAngleRadians.PI;
final double expected = -PlaneAngleRadians.PI;
final double actual = PlaneAngleRadians.normalizeBetweenMinusPiAndPi(value);
@@ -107,7 +107,7 @@ public class PlaneAngleRadiansTest {
Assertions.assertEquals(expected, actual, tol);
}
@Test
- public void testNormalizeBetweenMinusPiAndPi_upperBound() {
+ void testNormalizeBetweenMinusPiAndPi_upperBound() {
final double value = PlaneAngleRadians.PI;
final double expected = -PlaneAngleRadians.PI;
final double actual = PlaneAngleRadians.normalizeBetweenMinusPiAndPi(value);
@@ -116,7 +116,7 @@ public class PlaneAngleRadiansTest {
}
@Test
- public void testNormalizeBetweenZeroAndTwoPi1() {
+ void testNormalizeBetweenZeroAndTwoPi1() {
final double value = 1.25 * PlaneAngleRadians.TWO_PI;
final double expected = PlaneAngleRadians.PI_OVER_TWO;
final double actual = PlaneAngleRadians.normalizeBetweenZeroAndTwoPi(value);
@@ -124,7 +124,7 @@ public class PlaneAngleRadiansTest {
Assertions.assertEquals(expected, actual, tol);
}
@Test
- public void testNormalizeBetweenZeroAndTwoPi2() {
+ void testNormalizeBetweenZeroAndTwoPi2() {
final double value = 1.75 * PlaneAngleRadians.TWO_PI;
final double expected = PlaneAngleRadians.THREE_PI_OVER_TWO;
final double actual = PlaneAngleRadians.normalizeBetweenZeroAndTwoPi(value);
@@ -132,7 +132,7 @@ public class PlaneAngleRadiansTest {
Assertions.assertEquals(expected, actual, tol);
}
@Test
- public void testNormalizeBetweenZeroAndTwoPi3() {
+ void testNormalizeBetweenZeroAndTwoPi3() {
final double value = -PlaneAngleRadians.PI + 1e-10;
final double expected = PlaneAngleRadians.PI + 1e-10;
final double actual = PlaneAngleRadians.normalizeBetweenZeroAndTwoPi(value);
@@ -140,7 +140,7 @@ public class PlaneAngleRadiansTest {
Assertions.assertEquals(expected, actual, tol);
}
@Test
- public void testNormalizeBetweenZeroAndTwoPi4() {
+ void testNormalizeBetweenZeroAndTwoPi4() {
final double value = 9 * PlaneAngleRadians.PI / 4;
final double expected = PlaneAngleRadians.PI / 4;
final double actual = PlaneAngleRadians.normalizeBetweenZeroAndTwoPi(value);
@@ -149,7 +149,7 @@ public class PlaneAngleRadiansTest {
}
@Test
- public void testNormalizeBetweenZeroAndTwoPi_lowerBound() {
+ void testNormalizeBetweenZeroAndTwoPi_lowerBound() {
final double value = 0.0;
final double expected = 0.0;
final double actual = PlaneAngleRadians.normalizeBetweenZeroAndTwoPi(value);
@@ -157,7 +157,7 @@ public class PlaneAngleRadiansTest {
Assertions.assertEquals(expected, actual, tol);
}
@Test
- public void testNormalizeBetweenZeroAndTwoPi_upperBound() {
+ void testNormalizeBetweenZeroAndTwoPi_upperBound() {
final double value = PlaneAngleRadians.TWO_PI;
final double expected = 0.0;
final double actual = PlaneAngleRadians.normalizeBetweenZeroAndTwoPi(value);
diff --git a/commons-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleTest.java b/commons-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleTest.java
index 5cd2039..c61d024 100644
--- a/commons-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleTest.java
+++ b/commons-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleTest.java
@@ -24,14 +24,14 @@ import org.junit.jupiter.api.Test;
*/
public class PlaneAngleTest {
@Test
- public void testConversionTurns() {
+ void testConversionTurns() {
final double value = 12.3456;
final PlaneAngle a = PlaneAngle.ofTurns(value);
Assertions.assertEquals(value, a.toTurns(), 0d);
}
@Test
- public void testConversionRadians() {
+ void testConversionRadians() {
final double one = 2 * Math.PI;
final double value = 12.3456 * one;
final PlaneAngle a = PlaneAngle.ofRadians(value);
@@ -39,7 +39,7 @@ public class PlaneAngleTest {
}
@Test
- public void testConversionDegrees() {
+ void testConversionDegrees() {
final double one = 360;
final double value = 12.3456 * one;
final PlaneAngle a = PlaneAngle.ofDegrees(value);
@@ -47,7 +47,7 @@ public class PlaneAngleTest {
}
@Test
- public void testNormalizeRadians() {
+ void testNormalizeRadians() {
for (double a = -15.0; a <= 15.0; a += 0.1) {
for (double b = -15.0; b <= 15.0; b += 0.2) {
final PlaneAngle aA = PlaneAngle.ofRadians(a);
@@ -62,7 +62,7 @@ public class PlaneAngleTest {
}
@Test
- public void testNormalizeMixed() {
+ void testNormalizeMixed() {
for (double a = -15.0; a <= 15.0; a += 0.1) {
for (double b = -15.0; b <= 15.0; b += 0.2) {
final PlaneAngle aA = PlaneAngle.ofDegrees(a);
@@ -77,7 +77,7 @@ public class PlaneAngleTest {
}
@Test
- public void testNormalizeAroundZero1() {
+ void testNormalizeAroundZero1() {
final double value = 1.25;
final double expected = 0.25;
final double actual = PlaneAngle.ofTurns(value).normalize(PlaneAngle.ZERO).toTurns();
@@ -85,7 +85,7 @@ public class PlaneAngleTest {
Assertions.assertEquals(expected, actual, tol);
}
@Test
- public void testNormalizeAroundZero2() {
+ void testNormalizeAroundZero2() {
final double value = 0.75;
final double expected = -0.25;
final double actual = PlaneAngle.ofTurns(value).normalize(PlaneAngle.ZERO).toTurns();
@@ -93,7 +93,7 @@ public class PlaneAngleTest {
Assertions.assertEquals(expected, actual, tol);
}
@Test
- public void testNormalizeAroundZero3() {
+ void testNormalizeAroundZero3() {
final double value = 0.5 + 1e-10;
final double expected = -0.5 + 1e-10;
final double actual = PlaneAngle.ofTurns(value).normalize(PlaneAngle.ZERO).toTurns();
@@ -101,7 +101,7 @@ public class PlaneAngleTest {
Assertions.assertEquals(expected, actual, tol);
}
@Test
- public void testNormalizeAroundZero4() {
+ void testNormalizeAroundZero4() {
final double value = 5 * Math.PI / 4;
final double expected = Math.PI * (1d / 4 - 1);
final double actual = PlaneAngle.ofRadians(value).normalize(PlaneAngle.ZERO).toRadians();
@@ -110,7 +110,7 @@ public class PlaneAngleTest {
}
@Test
- public void testNormalizeUpperAndLowerBounds() {
+ void testNormalizeUpperAndLowerBounds() {
// arrange
double eps = 1e-15;
@@ -129,7 +129,7 @@ public class PlaneAngleTest {
}
@Test
- public void testNormalizeVeryCloseToBounds() {
+ void testNormalizeVeryCloseToBounds() {
// arrange
double eps = 1e-22;
@@ -151,7 +151,7 @@ public class PlaneAngleTest {
}
@Test
- public void testHashCode() {
+ void testHashCode() {
// Test assumes that the internal representation is in "turns".
final double value = -123.456789;
final int expected = Double.valueOf(value).hashCode();
@@ -160,7 +160,7 @@ public class PlaneAngleTest {
}
@Test
- public void testEquals() {
+ void testEquals() {
final double value = 12345.6789;
final PlaneAngle a = PlaneAngle.ofRadians(value);
Assertions.assertTrue(a.equals(a));
@@ -171,11 +171,11 @@ public class PlaneAngleTest {
}
@Test
- public void testZero() {
+ void testZero() {
Assertions.assertEquals(0, PlaneAngle.ZERO.toRadians(), 0d);
}
@Test
- public void testPi() {
+ void testPi() {
Assertions.assertEquals(Math.PI, PlaneAngle.PI.toRadians(), 0d);
}
}
diff --git a/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/CosAngleTest.java b/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/CosAngleTest.java
index 758ee3f..33f9e54 100644
--- a/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/CosAngleTest.java
+++ b/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/CosAngleTest.java
@@ -25,7 +25,7 @@ import org.junit.jupiter.api.Test;
public class CosAngleTest {
@Test
- public void testCosAngle2D() {
+ void testCosAngle2D() {
double expected;
final double[] v1 = {1, 0};
@@ -51,7 +51,7 @@ public class CosAngleTest {
}
@Test
- public void testCosAngle3D() {
+ void testCosAngle3D() {
double expected;
final double[] v1 = {1, 1, 0};
@@ -64,7 +64,7 @@ public class CosAngleTest {
}
@Test
- public void testCosAngleExtreme() {
+ void testCosAngleExtreme() {
double expected;
final double tiny = 1e-200;
@@ -80,7 +80,7 @@ public class CosAngleTest {
}
@Test
- public void testCosAngle_dimensionMismatch() {
+ void testCosAngle_dimensionMismatch() {
final double[] a = {1.0};
final double[] b = {1.0, 2.0};
diff --git a/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/LinearCombinationTest.java b/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/LinearCombinationTest.java
index 82894f6..fedb4e3 100644
--- a/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/LinearCombinationTest.java
+++ b/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/LinearCombinationTest.java
@@ -29,7 +29,7 @@ import org.apache.commons.numbers.fraction.BigFraction;
public class LinearCombinationTest {
// MATH-1005
@Test
- public void testSingleElementArray() {
+ void testSingleElementArray() {
final double[] a = {1.23456789};
final double[] b = {98765432.1};
@@ -37,7 +37,7 @@ public class LinearCombinationTest {
}
@Test
- public void testTwoSums() {
+ void testTwoSums() {
final BigFraction[] aF = new BigFraction[] {
BigFraction.of(-1321008684645961L, 268435456L),
BigFraction.of(-5774608829631843L, 268435456L),
@@ -77,7 +77,7 @@ public class LinearCombinationTest {
}
@Test
- public void testArrayVsInline() {
+ void testArrayVsInline() {
final UniformRandomProvider rng = RandomSource.create(RandomSource.XO_SHI_RO_256_PP);
double sInline;
@@ -114,7 +114,7 @@ public class LinearCombinationTest {
}
@Test
- public void testHuge() {
+ void testHuge() {
int scale = 971;
final double[] a = new double[] {
-1321008684645961.0 / 268435456.0,
@@ -147,7 +147,7 @@ public class LinearCombinationTest {
}
@Test
- public void testInfinite() {
+ void testInfinite() {
final double[][] a = new double[][] {
{1, 2, 3, 4},
{1, Double.POSITIVE_INFINITY, 3, 4},
diff --git a/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/MultidimensionalCounterTest.java b/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/MultidimensionalCounterTest.java
index 88f5815..b8f05b6 100644
--- a/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/MultidimensionalCounterTest.java
+++ b/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/MultidimensionalCounterTest.java
@@ -27,7 +27,7 @@ import org.junit.jupiter.api.Test;
*/
public class MultidimensionalCounterTest {
@Test
- public void testPreconditions() {
+ void testPreconditions() {
Assertions.assertThrows(IllegalArgumentException.class, () -> MultidimensionalCounter.of(0, 1));
Assertions.assertThrows(IllegalArgumentException.class, () -> MultidimensionalCounter.of(2, 0));
Assertions.assertThrows(IllegalArgumentException.class, () -> MultidimensionalCounter.of(-1, 1));
@@ -43,7 +43,7 @@ public class MultidimensionalCounterTest {
}
@Test
- public void testMulti2UniConversion() {
+ void testMulti2UniConversion() {
final MultidimensionalCounter c = MultidimensionalCounter.of(2, 4, 5);
Assertions.assertEquals(33, c.toUni(1, 2, 3));
@@ -53,7 +53,7 @@ public class MultidimensionalCounterTest {
}
@Test
- public void testAccessors() {
+ void testAccessors() {
final int[] originalSize = new int[] {2, 6, 5};
final MultidimensionalCounter c = MultidimensionalCounter.of(originalSize);
final int nDim = c.getDimension();
@@ -66,7 +66,7 @@ public class MultidimensionalCounterTest {
}
@Test
- public void testIterationConsistency() {
+ void testIterationConsistency() {
final MultidimensionalCounter c = MultidimensionalCounter.of(2, 3, 4);
final int[][] expected = new int[][] {
{0, 0, 0},
@@ -112,7 +112,7 @@ public class MultidimensionalCounterTest {
}
@Test
- public void testToString() {
+ void testToString() {
final int[] sizes = new int[] {7, 5, 3, 1};
final MultidimensionalCounter c = MultidimensionalCounter.of(sizes);
Assertions.assertEquals(Arrays.toString(sizes), c.toString());
diff --git a/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/SafeNormTest.java b/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/SafeNormTest.java
index 82de37c..b920918 100644
--- a/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/SafeNormTest.java
+++ b/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/SafeNormTest.java
@@ -25,48 +25,48 @@ import org.junit.jupiter.api.Test;
public class SafeNormTest {
@Test
- public void testTiny() {
+ void testTiny() {
final double s = 1e-320;
final double[] v = new double[] {s, s};
Assertions.assertEquals(Math.sqrt(2) * s, SafeNorm.value(v));
}
@Test
- public void testBig() {
+ void testBig() {
final double s = 1e300;
final double[] v = new double[] {s, s};
Assertions.assertEquals(Math.sqrt(2) * s, SafeNorm.value(v));
}
@Test
- public void testOne3D() {
+ void testOne3D() {
final double s = 1;
final double[] v = new double[] {s, s, s};
Assertions.assertEquals(Math.sqrt(3), SafeNorm.value(v));
}
@Test
- public void testUnit3D() {
+ void testUnit3D() {
Assertions.assertEquals(1, SafeNorm.value(new double[] {1, 0, 0}), 0d);
Assertions.assertEquals(1, SafeNorm.value(new double[] {0, 1, 0}), 0d);
Assertions.assertEquals(1, SafeNorm.value(new double[] {0, 0, 1}), 0d);
}
@Test
- public void testSimple() {
+ void testSimple() {
final double[] v = new double[] {-0.9, 8.7, -6.5, -4.3, -2.1, 0, 1.2, 3.4, -5.6, 7.8, 9.0};
final double expected = direct(v);
Assertions.assertEquals(expected, SafeNorm.value(v));
}
@Test
- public void testZero() {
+ void testZero() {
final double[] v = new double[] {0, 0, 0, 0, 0};
Assertions.assertEquals(0d, SafeNorm.value(v));
}
@Test
- public void testTinyAndSmallNormal() {
+ void testTinyAndSmallNormal() {
// Ensure the sum of the squared values for 'normal' values (1e-19*1e-19)
// is less than largest tiny value (1e-20)
final double[] v = new double[] {1e-20, 1e-19};
diff --git a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/BinomialCoefficientDoubleTest.java b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/BinomialCoefficientDoubleTest.java
index 1a17721..606b8be 100644
--- a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/BinomialCoefficientDoubleTest.java
+++ b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/BinomialCoefficientDoubleTest.java
@@ -25,12 +25,12 @@ import org.junit.jupiter.api.Test;
public class BinomialCoefficientDoubleTest {
/** Verify that b(0,0) = 1 */
@Test
- public void test0Choose0() {
+ void test0Choose0() {
Assertions.assertEquals(1d, BinomialCoefficientDouble.value(0, 0), 0);
}
@Test
- public void testBinomialCoefficient() {
+ void testBinomialCoefficient() {
final long[] bcoef5 = {1, 5, 10, 10, 5, 1};
final long[] bcoef6 = {1, 6, 15, 20, 15, 6, 1};
@@ -59,21 +59,21 @@ public class BinomialCoefficientDoubleTest {
}
@Test
- public void testBinomialCoefficientFail1() {
+ void testBinomialCoefficientFail1() {
Assertions.assertThrows(CombinatoricsException.class,
() -> BinomialCoefficientDouble.value(4, 5)
);
}
@Test
- public void testBinomialCoefficientFail2() {
+ void testBinomialCoefficientFail2() {
Assertions.assertThrows(CombinatoricsException.class,
() -> BinomialCoefficientDouble.value(-1, -2)
);
}
@Test
- public void testBinomialCoefficientFail3() {
+ void testBinomialCoefficientFail3() {
final double x = BinomialCoefficientDouble.value(1030, 515);
Assertions.assertTrue(Double.isInfinite(x), "expecting infinite binomial coefficient");
}
@@ -83,7 +83,7 @@ public class BinomialCoefficientDoubleTest {
* JIRA: MATH-241
*/
@Test
- public void testBinomialCoefficientLarge() throws Exception {
+ void testBinomialCoefficientLarge() throws Exception {
// This tests all legal and illegal values for n <= 200.
for (int n = 0; n <= 200; n++) {
for (int k = 0; k <= n; k++) {
diff --git a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/BinomialCoefficientTest.java b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/BinomialCoefficientTest.java
index 8080f80..341f9cc 100644
--- a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/BinomialCoefficientTest.java
+++ b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/BinomialCoefficientTest.java
@@ -33,12 +33,12 @@ public class BinomialCoefficientTest {
/** Verify that b(0,0) = 1 */
@Test
- public void test0Choose0() {
+ void test0Choose0() {
Assertions.assertEquals(1, BinomialCoefficient.value(0, 0));
}
@Test
- public void testBinomialCoefficient() {
+ void testBinomialCoefficient() {
final long[] bcoef5 = {1, 5, 10, 10, 5, 1};
final long[] bcoef6 = {1, 6, 15, 20, 15, 6, 1};
@@ -72,28 +72,28 @@ public class BinomialCoefficientTest {
}
@Test
- public void testBinomialCoefficientKLargerThanN() {
+ void testBinomialCoefficientKLargerThanN() {
Assertions.assertThrows(CombinatoricsException.class,
() -> BinomialCoefficient.value(4, 5)
);
}
@Test
- public void testBinomialCoefficientNegativeN() {
+ void testBinomialCoefficientNegativeN() {
Assertions.assertThrows(CombinatoricsException.class,
() -> BinomialCoefficient.value(-1, 1)
);
}
@Test
- public void testBinomialCoefficientNegativeK() {
+ void testBinomialCoefficientNegativeK() {
Assertions.assertThrows(CombinatoricsException.class,
() -> BinomialCoefficient.value(10, -1)
);
}
@Test
- public void testBinomialCoefficientNAbove66ResultOverflow() {
+ void testBinomialCoefficientNAbove66ResultOverflow() {
Assertions.assertThrows(ArithmeticException.class,
() -> BinomialCoefficient.value(67, 30)
);
@@ -104,7 +104,7 @@ public class BinomialCoefficientTest {
* JIRA: MATH-241
*/
@Test
- public void testBinomialCoefficientLarge() throws Exception {
+ void testBinomialCoefficientLarge() throws Exception {
// This tests all legal and illegal values for n <= 200.
for (int n = 0; n <= 200; n++) {
for (int k = 0; k <= n; k++) {
@@ -144,21 +144,21 @@ public class BinomialCoefficientTest {
}
@Test
- public void checkNLessThanOne() {
+ void checkNLessThanOne() {
Assertions.assertThrows(CombinatoricsException.class,
() -> BinomialCoefficient.checkBinomial(-1, -2)
);
}
@Test
- public void checkKGreaterThanN() {
+ void checkKGreaterThanN() {
Assertions.assertThrows(CombinatoricsException.class,
() -> BinomialCoefficient.checkBinomial(4, 5)
);
}
@Test
- public void testCheckBinomial3() {
+ void testCheckBinomial3() {
// OK (no exception thrown)
BinomialCoefficient.checkBinomial(5, 4);
}
diff --git a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/CombinationsTest.java b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/CombinationsTest.java
index ca3ead1..a32a42f 100644
--- a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/CombinationsTest.java
+++ b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/CombinationsTest.java
@@ -28,21 +28,21 @@ import org.junit.jupiter.api.Test;
*/
public class CombinationsTest {
@Test
- public void testGetN() {
+ void testGetN() {
final int n = 5;
final int k = 3;
Assertions.assertEquals(n, Combinations.of(n, k).getN());
}
@Test
- public void testGetK() {
+ void testGetK() {
final int n = 5;
final int k = 3;
Assertions.assertEquals(k, Combinations.of(n, k).getK());
}
@Test
- public void testLexicographicIterator() {
+ void testLexicographicIterator() {
checkLexicographicIterator(5, 3);
checkLexicographicIterator(6, 4);
checkLexicographicIterator(8, 2);
@@ -57,14 +57,14 @@ public class CombinationsTest {
}
@Test
- public void testLexicographicIteratorThrows() {
+ void testLexicographicIteratorThrows() {
checkLexicographicIteratorThrows(2, 1);
// Only 1 combination
checkLexicographicIteratorThrows(1, 1);
}
@Test
- public void testLexicographicComparatorWrongIterate1() {
+ void testLexicographicComparatorWrongIterate1() {
final int n = 5;
final int k = 3;
final Comparator<int[]> comp = Combinations.of(n, k).comparator();
@@ -74,7 +74,7 @@ public class CombinationsTest {
}
@Test
- public void testLexicographicComparatorWrongIterate2() {
+ void testLexicographicComparatorWrongIterate2() {
final int n = 5;
final int k = 3;
final Comparator<int[]> comp = Combinations.of(n, k).comparator();
@@ -84,7 +84,7 @@ public class CombinationsTest {
}
@Test
- public void testLexicographicComparatorWrongIterate3() {
+ void testLexicographicComparatorWrongIterate3() {
final int n = 5;
final int k = 3;
final Comparator<int[]> comp = Combinations.of(n, k).comparator();
@@ -94,7 +94,7 @@ public class CombinationsTest {
}
@Test
- public void testLexicographicComparatorWrongIterate4() {
+ void testLexicographicComparatorWrongIterate4() {
final int n = 5;
final int k = 3;
final Comparator<int[]> comp = Combinations.of(n, k).comparator();
@@ -104,7 +104,7 @@ public class CombinationsTest {
}
@Test
- public void testLexicographicComparator() {
+ void testLexicographicComparator() {
final int n = 5;
final int k = 3;
final Comparator<int[]> comp = Combinations.of(n, k).comparator();
@@ -120,7 +120,7 @@ public class CombinationsTest {
* Check that iterates can be passed unsorted.
*/
@Test
- public void testLexicographicComparatorUnsorted() {
+ void testLexicographicComparatorUnsorted() {
final int n = 5;
final int k = 3;
final Comparator<int[]> comp = Combinations.of(n, k).comparator();
@@ -133,7 +133,7 @@ public class CombinationsTest {
}
@Test
- public void testEmptyCombination() {
+ void testEmptyCombination() {
final Iterator<int[]> iter = Combinations.of(12345, 0).iterator();
Assertions.assertTrue(iter.hasNext());
final int[] c = iter.next();
@@ -142,7 +142,7 @@ public class CombinationsTest {
}
@Test
- public void testFullSetCombination() {
+ void testFullSetCombination() {
final int n = 67;
final Iterator<int[]> iter = Combinations.of(n, n).iterator();
Assertions.assertTrue(iter.hasNext());
@@ -215,28 +215,28 @@ public class CombinationsTest {
}
@Test
- public void testBinomialCoefficientKLargerThanN() {
+ void testBinomialCoefficientKLargerThanN() {
Assertions.assertThrows(CombinatoricsException.class,
() -> Combinations.of(4, 5)
);
}
@Test
- public void testBinomialCoefficientNegativeN() {
+ void testBinomialCoefficientNegativeN() {
Assertions.assertThrows(CombinatoricsException.class,
() -> Combinations.of(-1, 1)
);
}
@Test
- public void testBinomialCoefficientNegativeK() {
+ void testBinomialCoefficientNegativeK() {
Assertions.assertThrows(CombinatoricsException.class,
() -> Combinations.of(10, -1)
);
}
@Test
- public void testBinomialCoefficientKAboveN() {
+ void testBinomialCoefficientKAboveN() {
Assertions.assertThrows(CombinatoricsException.class,
() -> Combinations.of(10, 20)
);
diff --git a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialDoubleTest.java b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialDoubleTest.java
index c4075ea..9862b76 100644
--- a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialDoubleTest.java
+++ b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialDoubleTest.java
@@ -24,12 +24,12 @@ import org.junit.jupiter.api.Test;
*/
public class FactorialDoubleTest {
@Test
- public void testFactorialZero() {
+ void testFactorialZero() {
Assertions.assertEquals(1, FactorialDouble.create().value(0), 0d, "0!");
}
@Test
- public void testFactorialDirect() {
+ void testFactorialDirect() {
for (int i = 1; i < 21; i++) {
Assertions.assertEquals(
factorialDirect(i), FactorialDouble.create().value(i), 0d, i + "!");
@@ -37,35 +37,35 @@ public class FactorialDoubleTest {
}
@Test
- public void testLargestFactorialDouble() {
+ void testLargestFactorialDouble() {
final int n = 170;
Assertions.assertTrue(
Double.POSITIVE_INFINITY != FactorialDouble.create().value(n), n + "!");
}
@Test
- public void testFactorialDoubleTooLarge() {
+ void testFactorialDoubleTooLarge() {
final int n = 171;
Assertions.assertEquals(
Double.POSITIVE_INFINITY, FactorialDouble.create().value(n), 0d, n + "!");
}
@Test
- public void testNonPositiveArgumentWithCache() {
+ void testNonPositiveArgumentWithCache() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> FactorialDouble.create().withCache(-1)
);
}
@Test
- public void testNonPositiveArgument() {
+ void testNonPositiveArgument() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> FactorialDouble.create().value(-1)
);
}
@Test
- public void testCompareDirectWithoutCache() {
+ void testCompareDirectWithoutCache() {
// This test shows that delegating to the "Gamma" class will also lead to a
// less accurate result.
@@ -80,7 +80,7 @@ public class FactorialDoubleTest {
}
@Test
- public void testCompareDirectWithCache() {
+ void testCompareDirectWithCache() {
final int max = 100;
final FactorialDouble f = FactorialDouble.create().withCache(max);
@@ -92,7 +92,7 @@ public class FactorialDoubleTest {
}
@Test
- public void testCacheIncrease() {
+ void testCacheIncrease() {
final int max = 100;
final FactorialDouble f1 = FactorialDouble.create().withCache(max);
final FactorialDouble f2 = f1.withCache(2 * max);
@@ -102,7 +102,7 @@ public class FactorialDoubleTest {
}
@Test
- public void testZeroCache() {
+ void testZeroCache() {
// Ensure that no exception is thrown.
final FactorialDouble f = FactorialDouble.create().withCache(0);
Assertions.assertEquals(1, f.value(0), 0d);
@@ -110,7 +110,7 @@ public class FactorialDoubleTest {
}
@Test
- public void testUselessCache() {
+ void testUselessCache() {
Assertions.assertDoesNotThrow(() -> {
LogFactorial.create().withCache(1);
LogFactorial.create().withCache(2);
@@ -118,7 +118,7 @@ public class FactorialDoubleTest {
}
@Test
- public void testCacheDecrease() {
+ void testCacheDecrease() {
final int max = 100;
final FactorialDouble f1 = FactorialDouble.create().withCache(max);
final FactorialDouble f2 = f1.withCache(max / 2);
diff --git a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialTest.java b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialTest.java
index 4dba998..1579375 100644
--- a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialTest.java
+++ b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialTest.java
@@ -24,26 +24,26 @@ import org.junit.jupiter.api.Test;
*/
public class FactorialTest {
@Test
- public void testFactorialZero() {
+ void testFactorialZero() {
Assertions.assertEquals(1, Factorial.value(0), "0!");
}
@Test
- public void testFactorial() {
+ void testFactorial() {
for (int i = 1; i < 21; i++) {
Assertions.assertEquals(factorial(i), Factorial.value(i), i + "!");
}
}
@Test
- public void testPrecondition1() {
+ void testPrecondition1() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> Factorial.value(-1)
);
}
@Test
- public void testPrecondition2() {
+ void testPrecondition2() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> Factorial.value(21)
);
diff --git a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogBinomialCoefficientTest.java b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogBinomialCoefficientTest.java
index e8c20b6..fa36927 100644
--- a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogBinomialCoefficientTest.java
+++ b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogBinomialCoefficientTest.java
@@ -25,12 +25,12 @@ import org.junit.jupiter.api.Test;
public class LogBinomialCoefficientTest {
/** Verify that b(0,0) = 1 */
@Test
- public void test0Choose0() {
+ void test0Choose0() {
Assertions.assertEquals(0d, LogBinomialCoefficient.value(0, 0), 0);
}
@Test
- public void testBinomialCoefficient() {
+ void testBinomialCoefficient() {
final long[] bcoef5 = {1, 5, 10, 10, 5, 1};
final long[] bcoef6 = {1, 6, 15, 20, 15, 6, 1};
@@ -54,14 +54,14 @@ public class LogBinomialCoefficientTest {
}
@Test
- public void testBinomialCoefficientFail1() {
+ void testBinomialCoefficientFail1() {
Assertions.assertThrows(CombinatoricsException.class,
() -> LogBinomialCoefficient.value(4, 5)
);
}
@Test
- public void testBinomialCoefficientFail2() {
+ void testBinomialCoefficientFail2() {
Assertions.assertThrows(CombinatoricsException.class,
() -> LogBinomialCoefficient.value(-1, -2)
);
@@ -72,7 +72,7 @@ public class LogBinomialCoefficientTest {
* JIRA: MATH-241
*/
@Test
- public void testBinomialCoefficientLarge() throws Exception {
+ void testBinomialCoefficientLarge() throws Exception {
// This tests all legal and illegal values for n <= 200.
for (int n = 0; n <= 200; n++) {
for (int k = 0; k <= n; k++) {
diff --git a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogFactorialTest.java b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogFactorialTest.java
index 291c557..568335d 100644
--- a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogFactorialTest.java
+++ b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogFactorialTest.java
@@ -26,14 +26,14 @@ import org.junit.jupiter.api.Test;
*/
public class LogFactorialTest {
@Test
- public void testNonPositiveArgumentWithCache() {
+ void testNonPositiveArgumentWithCache() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> LogFactorial.create().withCache(-1)
);
}
@Test
- public void testNonPositiveArgument() {
+ void testNonPositiveArgument() {
final LogFactorial f = LogFactorial.create();
Assertions.assertThrows(IllegalArgumentException.class,
() -> f.value(-1)
@@ -41,7 +41,7 @@ public class LogFactorialTest {
}
@Test
- public void testDelegation() {
+ void testDelegation() {
final LogFactorial f = LogFactorial.create();
// Starting at 21 because for smaller arguments, there is no delegation to the
@@ -54,7 +54,7 @@ public class LogFactorialTest {
}
@Test
- public void testCompareDirectWithoutCache() {
+ void testCompareDirectWithoutCache() {
// This test shows that delegating to the "Gamma" class leads to difference
// wrt the "direct" computation.
@@ -69,7 +69,7 @@ public class LogFactorialTest {
}
@Test
- public void testCompareDirectWithCache() {
+ void testCompareDirectWithCache() {
final int max = 1000;
final LogFactorial f = LogFactorial.create().withCache(max);
@@ -81,7 +81,7 @@ public class LogFactorialTest {
}
@Test
- public void testZeroCache() {
+ void testZeroCache() {
// Ensure that no exception is thrown.
final LogFactorial f = LogFactorial.create().withCache(0);
Assertions.assertEquals(0, f.value(0), 0d);
@@ -89,14 +89,14 @@ public class LogFactorialTest {
}
@Test
- public void testUselessCache() {
+ void testUselessCache() {
// Ensure that no exception is thrown.
LogFactorial.create().withCache(1);
LogFactorial.create().withCache(2);
}
@Test
- public void testCacheIncrease() {
+ void testCacheIncrease() {
final int max = 100;
final LogFactorial f1 = LogFactorial.create().withCache(max);
final LogFactorial f2 = f1.withCache(2 * max);
@@ -107,7 +107,7 @@ public class LogFactorialTest {
}
@Test
- public void testCacheDecrease() {
+ void testCacheDecrease() {
final int max = 100;
final LogFactorial f1 = LogFactorial.create().withCache(max);
final LogFactorial f2 = f1.withCache(max / 2);
diff --git a/commons-numbers-complex-streams/src/test/java/org/apache/commons/numbers/complex/streams/ComplexUtilsTest.java b/commons-numbers-complex-streams/src/test/java/org/apache/commons/numbers/complex/streams/ComplexUtilsTest.java
index 3c43298..7bac2b1 100644
--- a/commons-numbers-complex-streams/src/test/java/org/apache/commons/numbers/complex/streams/ComplexUtilsTest.java
+++ b/commons-numbers-complex-streams/src/test/java/org/apache/commons/numbers/complex/streams/ComplexUtilsTest.java
@@ -237,7 +237,7 @@ public class ComplexUtilsTest {
// CHECKSTYLE: resume MethodLength
@Test
- public void testPolar2Complex() {
+ void testPolar2Complex() {
TestUtils.assertEquals(Complex.ONE, ComplexUtils.polar2Complex(1, 0), 10e-12);
TestUtils.assertEquals(Complex.ZERO, ComplexUtils.polar2Complex(0, 1), 10e-12);
TestUtils.assertEquals(Complex.ZERO, ComplexUtils.polar2Complex(0, -1), 10e-12);
@@ -312,42 +312,42 @@ public class ComplexUtilsTest {
}
@Test
- public void testPolar2ComplexIllegalModulus() {
+ void testPolar2ComplexIllegalModulus() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.polar2Complex(-1, 0)
);
}
@Test
- public void testPolar2ComplexIllegalModulus1D() {
+ void testPolar2ComplexIllegalModulus1D() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.polar2Complex(new double[]{0, -1, 2}, new double[]{0, 1, 2})
);
}
@Test
- public void testPolar2ComplexIllegalModulus2D() {
+ void testPolar2ComplexIllegalModulus2D() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.polar2Complex(new double[][]{{0, 2, 2}, {0, -1, 2}}, new double[][]{{0, 1, 2}, {0, 1, 2}})
);
}
@Test
- public void testPolar2ComplexIllegalModulus3D() {
+ void testPolar2ComplexIllegalModulus3D() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.polar2Complex(new double[][][]{{{0, 2, 2}}, {{0, -1, 2}}}, new double[][][]{{{0, 1, 2}}, {{0, 1, 2}}})
);
}
@Test
- public void testPolar2ComplexNaN() {
+ void testPolar2ComplexNaN() {
TestUtils.assertSame(NAN, ComplexUtils.polar2Complex(nan, 1));
TestUtils.assertSame(NAN, ComplexUtils.polar2Complex(1, nan));
TestUtils.assertSame(NAN, ComplexUtils.polar2Complex(nan, nan));
}
@Test
- public void testPolar2ComplexInf() {
+ void testPolar2ComplexInf() {
TestUtils.assertSame(NAN, ComplexUtils.polar2Complex(1, inf));
TestUtils.assertSame(NAN, ComplexUtils.polar2Complex(1, negInf));
TestUtils.assertSame(NAN, ComplexUtils.polar2Complex(inf, inf));
@@ -360,7 +360,7 @@ public class ComplexUtilsTest {
}
@Test
- public void testCExtract() {
+ void testCExtract() {
final double[] real = new double[] {negInf, -123.45, 0, 1, 234.56, pi, inf};
final Complex[] complex = ComplexUtils.real2Complex(real);
@@ -372,7 +372,7 @@ public class ComplexUtilsTest {
// EXTRACTION METHODS
@Test
- public void testExtractionMethods() {
+ void testExtractionMethods() {
setArrays();
// Extract complex from real double array, index 3
TestUtils.assertSame(Complex.ofCartesian(3, 0), ComplexUtils.extractComplexFromRealArray(d, 3));
@@ -408,7 +408,7 @@ public class ComplexUtilsTest {
// REAL <-> COMPLEX
@Test
- public void testRealToComplex() {
+ void testRealToComplex() {
setArrays();
// Real double to complex, whole array
TestUtils.assertEquals(msg, cr, ComplexUtils.real2Complex(d), Math.ulp(1.0));
@@ -428,7 +428,7 @@ public class ComplexUtilsTest {
}
@Test
- public void testComplexToReal() {
+ void testComplexToReal() {
setArrays();
// Real complex to double, whole array
Assertions.assertArrayEquals(sr, ComplexUtils.complex2Real(c), Math.ulp(1.0), msg);
@@ -451,7 +451,7 @@ public class ComplexUtilsTest {
// IMAGINARY <-> COMPLEX
@Test
- public void testImaginaryToComplex() {
+ void testImaginaryToComplex() {
setArrays();
// Imaginary double to complex, whole array
TestUtils.assertEquals(msg, ci, ComplexUtils.imaginary2Complex(d), Math.ulp(1.0));
@@ -469,7 +469,7 @@ public class ComplexUtilsTest {
}
@Test
- public void testComplexToImaginary() {
+ void testComplexToImaginary() {
setArrays();
// Imaginary complex to double, whole array
Assertions.assertArrayEquals(si, ComplexUtils.complex2Imaginary(c), Math.ulp(1.0), msg);
@@ -492,147 +492,147 @@ public class ComplexUtilsTest {
// INTERLEAVED <-> COMPLEX
@Test
- public void testComplex2InterleavedIllegalIndex2Dmin() {
+ void testComplex2InterleavedIllegalIndex2Dmin() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.complex2Interleaved(c2d, -1)
);
}
@Test
- public void testComplex2InterleavedIllegalIndex2Dmax() {
+ void testComplex2InterleavedIllegalIndex2Dmax() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.complex2Interleaved(c2d, 2)
);
}
@Test
- public void testComplex2InterleavedIllegalIndex3Dmin() {
+ void testComplex2InterleavedIllegalIndex3Dmin() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.complex2Interleaved(c3d, -1)
);
}
@Test
- public void testComplex2InterleavedIllegalIndex3Dmax() {
+ void testComplex2InterleavedIllegalIndex3Dmax() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.complex2Interleaved(c3d, 3)
);
}
@Test
- public void testComplex2InterleavedIllegalIndex4Dmin() {
+ void testComplex2InterleavedIllegalIndex4Dmin() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.complex2Interleaved(c4d, -1)
);
}
@Test
- public void testComplex2InterleavedIllegalIndex4Dmax() {
+ void testComplex2InterleavedIllegalIndex4Dmax() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.complex2Interleaved(c4d, 4)
);
}
@Test
- public void testComplex2InterleavedFloatIllegalIndex2Dmin() {
+ void testComplex2InterleavedFloatIllegalIndex2Dmin() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.complex2InterleavedFloat(c2d, -1)
);
}
@Test
- public void testComplex2InterleavedFloatIllegalIndex2Dmax() {
+ void testComplex2InterleavedFloatIllegalIndex2Dmax() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.complex2InterleavedFloat(c2d, 2)
);
}
@Test
- public void testComplex2InterleavedFloatIllegalIndex3Dmin() {
+ void testComplex2InterleavedFloatIllegalIndex3Dmin() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.complex2InterleavedFloat(c3d, -1)
);
}
@Test
- public void testComplex2InterleavedFloatIllegalIndex3Dmax() {
+ void testComplex2InterleavedFloatIllegalIndex3Dmax() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.complex2InterleavedFloat(c3d, 3)
);
}
@Test
- public void testInterleaved2ComplexIllegalIndex2Dmin() {
+ void testInterleaved2ComplexIllegalIndex2Dmin() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.interleaved2Complex(di2d0, -1)
);
}
@Test
- public void testInterleaved2ComplexIllegalIndex2Dmax() {
+ void testInterleaved2ComplexIllegalIndex2Dmax() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.interleaved2Complex(di2d0, 2)
);
}
@Test
- public void testInterleaved2ComplexIllegalIndex3Dmin() {
+ void testInterleaved2ComplexIllegalIndex3Dmin() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.interleaved2Complex(di3d0, -1)
);
}
@Test
- public void testInterleaved2ComplexIllegalIndex3Dmax() {
+ void testInterleaved2ComplexIllegalIndex3Dmax() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.interleaved2Complex(di3d0, 3)
);
}
@Test
- public void testInterleaved2ComplexIllegalIndex4Dmin() {
+ void testInterleaved2ComplexIllegalIndex4Dmin() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.interleaved2Complex(di4d0, -1)
);
}
@Test
- public void testInterleaved2ComplexIllegalIndex4Dmax() {
+ void testInterleaved2ComplexIllegalIndex4Dmax() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.interleaved2Complex(di4d0, 4)
);
}
@Test
- public void testInterleaved2ComplexFloatIllegalIndex2Dmin() {
+ void testInterleaved2ComplexFloatIllegalIndex2Dmin() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.interleaved2Complex(fi2d0, -1)
);
}
@Test
- public void testInterleaved2ComplexFloatIllegalIndex2Dmax() {
+ void testInterleaved2ComplexFloatIllegalIndex2Dmax() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.interleaved2Complex(fi2d0, 2)
);
}
@Test
- public void testInterleaved2ComplexFloatIllegalIndex3Dmin() {
+ void testInterleaved2ComplexFloatIllegalIndex3Dmin() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.interleaved2Complex(fi3d0, -1)
);
}
@Test
- public void testInterleaved2ComplexFloatIllegalIndex3Dmax() {
+ void testInterleaved2ComplexFloatIllegalIndex3Dmax() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.interleaved2Complex(fi3d0, 3)
);
}
@Test
- public void testInterleavedToComplex() {
+ void testInterleavedToComplex() {
setArrays();
// Interleaved double to complex, whole array
TestUtils.assertEquals(msg, c, ComplexUtils.interleaved2Complex(di), Math.ulp(1.0));
@@ -667,7 +667,7 @@ public class ComplexUtilsTest {
}
@Test
- public void testComplexToInterleaved() {
+ void testComplexToInterleaved() {
setArrays();
Assertions.assertArrayEquals(di, ComplexUtils.complex2Interleaved(c), Math.ulp(1.0), msg);
// Interleaved complex to float, whole array
@@ -703,7 +703,7 @@ public class ComplexUtilsTest {
// SPLIT TO COMPLEX
@Test
- public void testSplit2Complex() {
+ void testSplit2Complex() {
setArrays();
// Split double to complex, whole array
TestUtils.assertEquals(msg, c, ComplexUtils.split2Complex(sr, si), Math.ulp(1.0));
@@ -718,7 +718,7 @@ public class ComplexUtilsTest {
// INITIALIZATION METHODS
@Test
- public void testInitialize() {
+ void testInitialize() {
Complex[] complexes = new Complex[10];
ComplexUtils.initialize(complexes);
for (Complex cc : complexes) {
@@ -727,7 +727,7 @@ public class ComplexUtilsTest {
}
@Test
- public void testInitialize2d() {
+ void testInitialize2d() {
Complex[][] complexes = new Complex[10][10];
ComplexUtils.initialize(complexes);
for (Complex[] c1 : complexes) {
@@ -738,7 +738,7 @@ public class ComplexUtilsTest {
}
@Test
- public void testInitialize3d() {
+ void testInitialize3d() {
Complex[][][] complexes = new Complex[10][10][10];
ComplexUtils.initialize(complexes);
for (Complex[][] c2 : complexes) {
@@ -751,7 +751,7 @@ public class ComplexUtilsTest {
}
@Test
- public void testAbs() {
+ void testAbs() {
setArrays();
double[] observed = ComplexUtils.abs(c);
Assertions.assertEquals(c.length, observed.length);
@@ -761,7 +761,7 @@ public class ComplexUtilsTest {
}
@Test
- public void testArg() {
+ void testArg() {
setArrays();
double[] observed = ComplexUtils.arg(c);
Assertions.assertEquals(c.length, observed.length);
diff --git a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CReferenceTest.java b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CReferenceTest.java
index 6eab130..322c946 100644
--- a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CReferenceTest.java
+++ b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CReferenceTest.java
@@ -266,72 +266,72 @@ public class CReferenceTest {
}
@Test
- public void testAcos() {
+ void testAcos() {
assertOperation("acos", Complex::acos, 2);
}
@Test
- public void testAcosh() {
+ void testAcosh() {
assertOperation("acosh", Complex::acosh, 2);
}
@Test
- public void testAsinh() {
+ void testAsinh() {
// Odd function: negative real cases defined by positive real cases
assertOperation("asinh", Complex::asinh, 3);
}
@Test
- public void testAtanh() {
+ void testAtanh() {
// Odd function: negative real cases defined by positive real cases
assertOperation("atanh", Complex::atanh, 1);
}
@Test
- public void testCosh() {
+ void testCosh() {
// Even function: negative real cases defined by positive real cases
assertOperation("cosh", Complex::cosh, 2);
}
@Test
- public void testSinh() {
+ void testSinh() {
// Odd function: negative real cases defined by positive real cases
assertOperation("sinh", Complex::sinh, 2);
}
@Test
- public void testTanh() {
+ void testTanh() {
// Odd function: negative real cases defined by positive real cases
assertOperation("tanh", Complex::tanh, 2);
}
@Test
- public void testExp() {
+ void testExp() {
assertOperation("exp", Complex::exp, 2);
}
@Test
- public void testLog() {
+ void testLog() {
assertOperation("log", Complex::log, 1);
}
@Test
- public void testSqrt() {
+ void testSqrt() {
assertOperation("sqrt", Complex::sqrt, 1);
}
@Test
- public void testMultiply() {
+ void testMultiply() {
assertBiOperation("multiply", Complex::multiply, 0);
}
@Test
- public void testDivide() {
+ void testDivide() {
assertBiOperation("divide", Complex::divide, 7);
}
@Test
- public void testPowComplex() {
+ void testPowComplex() {
assertBiOperation("pow", Complex::pow, 9);
}
}
diff --git a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CStandardTest.java b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CStandardTest.java
index cd9b47c..09f8489 100644
--- a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CStandardTest.java
+++ b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CStandardTest.java
@@ -724,7 +724,7 @@ public class CStandardTest {
* ISO C Standard G.5 (4).
*/
@Test
- public void testMultiply() {
+ void testMultiply() {
final ArrayList<Complex> infinites = createInfinites();
final ArrayList<Complex> nonZeroFinites = createNonZeroFinites();
final ArrayList<Complex> zeroFinites = createZeroFinites();
@@ -783,7 +783,7 @@ public class CStandardTest {
* ISO C Standard G.5 (4).
*/
@Test
- public void testDivide() {
+ void testDivide() {
final ArrayList<Complex> infinites = createInfinites();
final ArrayList<Complex> nonZeroFinites = createNonZeroFinites();
final ArrayList<Complex> zeroFinites = createZeroFinites();
@@ -850,7 +850,7 @@ public class CStandardTest {
* ISO C Standard G.6 (3).
*/
@Test
- public void testSqrt1() {
+ void testSqrt1() {
assertComplex(complex(-2.0, 0.0).sqrt(), complex(0.0, Math.sqrt(2)));
assertComplex(complex(-2.0, -0.0).sqrt(), complex(0.0, -Math.sqrt(2)));
}
@@ -859,7 +859,7 @@ public class CStandardTest {
* ISO C Standard G.6 (7).
*/
@Test
- public void testImplicitTrig() {
+ void testImplicitTrig() {
final UniformRandomProvider rng = RandomSource.create(RandomSource.SPLIT_MIX_64);
for (int i = 0; i < 100; i++) {
final double re = next(rng);
@@ -890,7 +890,7 @@ public class CStandardTest {
* Functionality is defined by ISO C Standard F.9.4.3 hypot function.
*/
@Test
- public void testAbs() {
+ void testAbs() {
Assertions.assertEquals(inf, complex(inf, nan).abs());
Assertions.assertEquals(inf, complex(negInf, nan).abs());
final UniformRandomProvider rng = RandomSource.create(RandomSource.XO_RO_SHI_RO_128_PP);
@@ -975,7 +975,7 @@ public class CStandardTest {
* ISO C Standard G.6.1.1.
*/
@Test
- public void testAcos() {
+ void testAcos() {
final UnaryOperator<Complex> operation = Complex::acos;
assertConjugateEquality(operation);
assertComplex(Complex.ZERO, operation, piTwoNegZero);
@@ -1012,7 +1012,7 @@ public class CStandardTest {
* Complex math functions cacosh and ctanh</a>
*/
@Test
- public void testAcosh() {
+ void testAcosh() {
final UnaryOperator<Complex> operation = Complex::acosh;
assertConjugateEquality(operation);
assertComplex(Complex.ZERO, operation, zeroPiTwo);
@@ -1046,7 +1046,7 @@ public class CStandardTest {
* ISO C Standard G.6.2.2.
*/
@Test
- public void testAsinh() {
+ void testAsinh() {
final UnaryOperator<Complex> operation = Complex::asinh;
final FunctionType type = FunctionType.ODD;
assertConjugateEquality(operation);
@@ -1075,7 +1075,7 @@ public class CStandardTest {
* ISO C Standard G.6.2.3.
*/
@Test
- public void testAtanh() {
+ void testAtanh() {
final UnaryOperator<Complex> operation = Complex::atanh;
final FunctionType type = FunctionType.ODD;
assertConjugateEquality(operation);
@@ -1106,7 +1106,7 @@ public class CStandardTest {
* ISO C Standard G.6.2.4.
*/
@Test
- public void testCosh() {
+ void testCosh() {
final UnaryOperator<Complex> operation = Complex::cosh;
final FunctionType type = FunctionType.EVEN;
assertConjugateEquality(operation);
@@ -1137,7 +1137,7 @@ public class CStandardTest {
* ISO C Standard G.6.2.5.
*/
@Test
- public void testSinh() {
+ void testSinh() {
final UnaryOperator<Complex> operation = Complex::sinh;
final FunctionType type = FunctionType.ODD;
assertConjugateEquality(operation);
@@ -1172,7 +1172,7 @@ public class CStandardTest {
* Complex math functions cacosh and ctanh</a>
*/
@Test
- public void testTanh() {
+ void testTanh() {
final UnaryOperator<Complex> operation = Complex::tanh;
final FunctionType type = FunctionType.ODD;
assertConjugateEquality(operation);
@@ -1202,7 +1202,7 @@ public class CStandardTest {
* ISO C Standard G.6.3.1.
*/
@Test
- public void testExp() {
+ void testExp() {
final UnaryOperator<Complex> operation = Complex::exp;
assertConjugateEquality(operation);
assertComplex(Complex.ZERO, operation, oneZero);
@@ -1235,7 +1235,7 @@ public class CStandardTest {
* ISO C Standard G.6.3.2.
*/
@Test
- public void testLog() {
+ void testLog() {
final UnaryOperator<Complex> operation = Complex::log;
assertConjugateEquality(operation);
assertComplex(negZeroZero, operation, negInfPi);
@@ -1268,7 +1268,7 @@ public class CStandardTest {
* has no effect on infinite or nan.
*/
@Test
- public void testLog10() {
+ void testLog10() {
final UnaryOperator<Complex> operation = Complex::log10;
assertConjugateEquality(operation);
assertComplex(negZeroZero, operation, negInfPi);
@@ -1300,7 +1300,7 @@ public class CStandardTest {
* ISO C Standard G.6.4.2.
*/
@Test
- public void testSqrt() {
+ void testSqrt() {
final UnaryOperator<Complex> operation = Complex::sqrt;
assertConjugateEquality(operation);
assertComplex(negZeroZero, operation, Complex.ZERO);
diff --git a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexEdgeCaseTest.java b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexEdgeCaseTest.java
index 4f76f4d..351baa9 100644
--- a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexEdgeCaseTest.java
+++ b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexEdgeCaseTest.java
@@ -129,7 +129,7 @@ public class ComplexEdgeCaseTest {
}
@Test
- public void testAcos() {
+ void testAcos() {
// acos(z) = (pi / 2) + i ln(iz + sqrt(1 - z^2))
final String name = "acos";
final UnaryOperator<Complex> operation = Complex::acos;
@@ -165,7 +165,7 @@ public class ComplexEdgeCaseTest {
// acosh is defined by acos so is not tested
@Test
- public void testAsin() {
+ void testAsin() {
// asin(z) = -i (ln(iz + sqrt(1 - z^2)))
final String name = "asin";
final UnaryOperator<Complex> operation = Complex::asin;
@@ -198,7 +198,7 @@ public class ComplexEdgeCaseTest {
// asinh is defined by asin so is not tested
@Test
- public void testAtanh() {
+ void testAtanh() {
// atanh(z) = (1/2) ln((1 + z) / (1 - z))
// Odd function: negative real cases defined by positive real cases
final String name = "atanh";
@@ -227,7 +227,7 @@ public class ComplexEdgeCaseTest {
}
@Test
- public void testCosh() {
+ void testCosh() {
// cosh(a + b i) = cosh(a)cos(b) + i sinh(a)sin(b)
// Even function: negative real cases defined by positive real cases
final String name = "cosh";
@@ -292,7 +292,7 @@ public class ComplexEdgeCaseTest {
}
@Test
- public void testSinh() {
+ void testSinh() {
// sinh(a + b i) = sinh(a)cos(b) + i cosh(a)sin(b)
// Odd function: negative real cases defined by positive real cases
final String name = "sinh";
@@ -355,7 +355,7 @@ public class ComplexEdgeCaseTest {
}
@Test
- public void testTanh() {
+ void testTanh() {
// tan(a + b i) = sinh(2a)/(cosh(2a)+cos(2b)) + i [sin(2b)/(cosh(2a)+cos(2b))]
// Odd function: negative real cases defined by positive real cases
final String name = "tanh";
@@ -402,7 +402,7 @@ public class ComplexEdgeCaseTest {
}
@Test
- public void testExp() {
+ void testExp() {
final String name = "exp";
final UnaryOperator<Complex> operation = Complex::exp;
@@ -424,7 +424,7 @@ public class ComplexEdgeCaseTest {
}
@Test
- public void testLog() {
+ void testLog() {
final String name = "log";
final UnaryOperator<Complex> operation = Complex::log;
@@ -558,7 +558,7 @@ public class ComplexEdgeCaseTest {
}
@Test
- public void testSqrt() {
+ void testSqrt() {
final String name = "sqrt";
final UnaryOperator<Complex> operation = Complex::sqrt;
@@ -640,7 +640,7 @@ public class ComplexEdgeCaseTest {
// multiply/divide are tested in CStandardTest
@Test
- public void testDivide() {
+ void testDivide() {
final String name = "divide";
final BiFunction<Complex, Complex, Complex> operation = Complex::divide;
@@ -680,7 +680,7 @@ public class ComplexEdgeCaseTest {
}
@Test
- public void testPow() {
+ void testPow() {
final String name = "pow";
final BiFunction<Complex, Complex, Complex> operation = Complex::pow;
diff --git a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexTest.java b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexTest.java
index 1dcf513..b0c006e 100644
--- a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexTest.java
+++ b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexTest.java
@@ -96,7 +96,7 @@ public class ComplexTest {
@Test
@Disabled("Used to output the java environment")
@SuppressWarnings("squid:S2699")
- public void testJava() {
+ void testJava() {
// CHECKSTYLE: stop Regexp
System.out.println(">>testJava()");
// MathTest#testExpSpecialCases() checks the following:
@@ -126,14 +126,14 @@ public class ComplexTest {
}
@Test
- public void testCartesianConstructor() {
+ void testCartesianConstructor() {
final Complex z = Complex.ofCartesian(3.0, 4.0);
Assertions.assertEquals(3.0, z.getReal());
Assertions.assertEquals(4.0, z.getImaginary());
}
@Test
- public void testPolarConstructor() {
+ void testPolarConstructor() {
final double r = 98765;
final double theta = 0.12345;
final Complex z = Complex.ofPolar(r, theta);
@@ -167,7 +167,7 @@ public class ComplexTest {
}
@Test
- public void testPolarConstructorAbsArg() {
+ void testPolarConstructorAbsArg() {
// The test should work with any seed but use a fixed seed to avoid build
// instability.
final UniformRandomProvider rng = RandomSource.create(RandomSource.SPLIT_MIX_64, 678678638L);
@@ -183,7 +183,7 @@ public class ComplexTest {
}
@Test
- public void testCisConstructor() {
+ void testCisConstructor() {
final double x = 0.12345;
final Complex z = Complex.ofCis(x);
Assertions.assertEquals(Math.cos(x), z.getReal());
@@ -194,7 +194,7 @@ public class ComplexTest {
* Test parse and toString are compatible.
*/
@Test
- public void testParseAndToString() {
+ void testParseAndToString() {
final double[] parts = {Double.NEGATIVE_INFINITY, -1, -0.0, 0.0, 1, Math.PI, Double.POSITIVE_INFINITY,
Double.NaN};
for (final double x : parts) {
@@ -217,42 +217,42 @@ public class ComplexTest {
}
@Test
- public void testParseNull() {
+ void testParseNull() {
Assertions.assertThrows(NullPointerException.class, () -> Complex.parse(null));
}
@Test
- public void testParseEmpty() {
+ void testParseEmpty() {
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse(""));
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse(" "));
}
@Test
- public void testParseWrongStart() {
+ void testParseWrongStart() {
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse("1.0,2.0)"));
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse("[1.0,2.0)"));
}
@Test
- public void testParseWrongEnd() {
+ void testParseWrongEnd() {
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse("(1.0,2.0"));
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse("(1.0,2.0]"));
}
@Test
- public void testParseWrongSeparator() {
+ void testParseWrongSeparator() {
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse("(1.0 2.0)"));
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse("(1.0:2.0)"));
}
@Test
- public void testParseSeparatorOutsideStartAndEnd() {
+ void testParseSeparatorOutsideStartAndEnd() {
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse("(1.0,2.0),"));
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse(",(1.0,2.0)"));
}
@Test
- public void testParseExtraSeparator() {
+ void testParseExtraSeparator() {
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse("(1.0,,2.0)"));
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse("(1.0,2.0,)"));
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse("(,1.0,2.0)"));
@@ -260,17 +260,17 @@ public class ComplexTest {
}
@Test
- public void testParseInvalidRe() {
+ void testParseInvalidRe() {
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse("(I.0,2.0)"));
}
@Test
- public void testParseInvalidIm() {
+ void testParseInvalidIm() {
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse("(1.0,2.G)"));
}
@Test
- public void testParseSpaceAllowedAroundNumbers() {
+ void testParseSpaceAllowedAroundNumbers() {
final double re = 1.234;
final double im = 5.678;
final Complex z = Complex.ofCartesian(re, im);
@@ -283,7 +283,7 @@ public class ComplexTest {
}
@Test
- public void testCGrammar() {
+ void testCGrammar() {
final UniformRandomProvider rng = RandomSource.create(RandomSource.SPLIT_MIX_64);
for (int i = 0; i < 10; i++) {
final Complex z = Complex.ofCartesian(rng.nextDouble(), rng.nextDouble());
@@ -293,13 +293,13 @@ public class ComplexTest {
}
@Test
- public void testAbs() {
+ void testAbs() {
final Complex z = Complex.ofCartesian(3.0, 4.0);
Assertions.assertEquals(5.0, z.abs());
}
@Test
- public void testAbsNaN() {
+ void testAbsNaN() {
// The result is NaN if either argument is NaN and the other is not infinite
Assertions.assertEquals(nan, NAN.abs());
Assertions.assertEquals(nan, Complex.ofCartesian(3.0, nan).abs());
@@ -319,7 +319,7 @@ public class ComplexTest {
* Test standard values
*/
@Test
- public void testArg() {
+ void testArg() {
Complex z = Complex.ofCartesian(1, 0);
assertArgument(0.0, z, 1.0e-12);
@@ -349,7 +349,7 @@ public class ComplexTest {
* Verify atan2-style handling of infinite parts
*/
@Test
- public void testArgInf() {
+ void testArgInf() {
assertArgument(Math.PI / 4, infInf, 1.0e-12);
assertArgument(Math.PI / 2, oneInf, 1.0e-12);
assertArgument(0.0, infOne, 1.0e-12);
@@ -364,7 +364,7 @@ public class ComplexTest {
* Verify that either part NaN results in NaN
*/
@Test
- public void testArgNaN() {
+ void testArgNaN() {
assertArgument(Double.NaN, nanZero, 0);
assertArgument(Double.NaN, zeroNan, 0);
assertArgument(Double.NaN, NAN, 0);
@@ -377,13 +377,13 @@ public class ComplexTest {
}
@Test
- public void testNorm() {
+ void testNorm() {
final Complex z = Complex.ofCartesian(3.0, 4.0);
Assertions.assertEquals(25.0, z.norm());
}
@Test
- public void testNormNaN() {
+ void testNormNaN() {
// The result is NaN if either argument is NaN and the other is not infinite
Assertions.assertEquals(nan, NAN.norm());
Assertions.assertEquals(nan, Complex.ofCartesian(3.0, nan).norm());
@@ -399,7 +399,7 @@ public class ComplexTest {
* Test all number types: isNaN, isInfinite, isFinite.
*/
@Test
- public void testNumberType() {
+ void testNumberType() {
assertNumberType(0, 0, NumberType.FINITE);
assertNumberType(1, 0, NumberType.FINITE);
assertNumberType(0, 1, NumberType.FINITE);
@@ -457,7 +457,7 @@ public class ComplexTest {
}
@Test
- public void testConjugate() {
+ void testConjugate() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final Complex z = x.conj();
Assertions.assertEquals(3.0, z.getReal());
@@ -465,13 +465,13 @@ public class ComplexTest {
}
@Test
- public void testConjugateNaN() {
+ void testConjugateNaN() {
final Complex z = NAN.conj();
Assertions.assertTrue(z.isNaN());
}
@Test
- public void testConjugateInfinite() {
+ void testConjugateInfinite() {
Complex z = Complex.ofCartesian(0, inf);
Assertions.assertEquals(neginf, z.conj().getImaginary());
z = Complex.ofCartesian(0, neginf);
@@ -479,7 +479,7 @@ public class ComplexTest {
}
@Test
- public void testNegate() {
+ void testNegate() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final Complex z = x.negate();
Assertions.assertEquals(-3.0, z.getReal());
@@ -487,13 +487,13 @@ public class ComplexTest {
}
@Test
- public void testNegateNaN() {
+ void testNegateNaN() {
final Complex z = NAN.negate();
Assertions.assertTrue(z.isNaN());
}
@Test
- public void testProj() {
+ void testProj() {
final Complex z = Complex.ofCartesian(3.0, 4.0);
Assertions.assertSame(z, z.proj());
// Sign must be the same for projection
@@ -509,7 +509,7 @@ public class ComplexTest {
}
@Test
- public void testAdd() {
+ void testAdd() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final Complex y = Complex.ofCartesian(5.0, 6.0);
final Complex z = x.add(y);
@@ -518,7 +518,7 @@ public class ComplexTest {
}
@Test
- public void testAddInf() {
+ void testAddInf() {
Complex x = Complex.ofCartesian(1, 1);
final Complex z = Complex.ofCartesian(inf, 0);
final Complex w = x.add(z);
@@ -530,7 +530,7 @@ public class ComplexTest {
}
@Test
- public void testAddReal() {
+ void testAddReal() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 5.0;
final Complex z = x.add(y);
@@ -541,7 +541,7 @@ public class ComplexTest {
}
@Test
- public void testAddRealNaN() {
+ void testAddRealNaN() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = nan;
final Complex z = x.add(y);
@@ -552,7 +552,7 @@ public class ComplexTest {
}
@Test
- public void testAddRealInf() {
+ void testAddRealInf() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = inf;
final Complex z = x.add(y);
@@ -563,7 +563,7 @@ public class ComplexTest {
}
@Test
- public void testAddRealWithNegZeroImaginary() {
+ void testAddRealWithNegZeroImaginary() {
final Complex x = Complex.ofCartesian(3.0, -0.0);
final double y = 5.0;
final Complex z = x.add(y);
@@ -576,7 +576,7 @@ public class ComplexTest {
}
@Test
- public void testAddImaginary() {
+ void testAddImaginary() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 5.0;
final Complex z = x.addImaginary(y);
@@ -587,7 +587,7 @@ public class ComplexTest {
}
@Test
- public void testAddImaginaryNaN() {
+ void testAddImaginaryNaN() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = nan;
final Complex z = x.addImaginary(y);
@@ -598,7 +598,7 @@ public class ComplexTest {
}
@Test
- public void testAddImaginaryInf() {
+ void testAddImaginaryInf() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = inf;
final Complex z = x.addImaginary(y);
@@ -609,7 +609,7 @@ public class ComplexTest {
}
@Test
- public void testAddImaginaryWithNegZeroReal() {
+ void testAddImaginaryWithNegZeroReal() {
final Complex x = Complex.ofCartesian(-0.0, 4.0);
final double y = 5.0;
final Complex z = x.addImaginary(y);
@@ -622,7 +622,7 @@ public class ComplexTest {
}
@Test
- public void testSubtract() {
+ void testSubtract() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final Complex y = Complex.ofCartesian(5.0, 7.0);
final Complex z = x.subtract(y);
@@ -631,7 +631,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractInf() {
+ void testSubtractInf() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final Complex y = Complex.ofCartesian(inf, 7.0);
Complex z = x.subtract(y);
@@ -644,7 +644,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractReal() {
+ void testSubtractReal() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 5.0;
final Complex z = x.subtract(y);
@@ -655,7 +655,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractRealNaN() {
+ void testSubtractRealNaN() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = nan;
final Complex z = x.subtract(y);
@@ -666,7 +666,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractRealInf() {
+ void testSubtractRealInf() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = inf;
final Complex z = x.subtract(y);
@@ -677,7 +677,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractRealWithNegZeroImaginary() {
+ void testSubtractRealWithNegZeroImaginary() {
final Complex x = Complex.ofCartesian(3.0, -0.0);
final double y = 5.0;
final Complex z = x.subtract(y);
@@ -689,7 +689,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractImaginary() {
+ void testSubtractImaginary() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 5.0;
final Complex z = x.subtractImaginary(y);
@@ -700,7 +700,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractImaginaryNaN() {
+ void testSubtractImaginaryNaN() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = nan;
final Complex z = x.subtractImaginary(y);
@@ -711,7 +711,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractImaginaryInf() {
+ void testSubtractImaginaryInf() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = inf;
final Complex z = x.subtractImaginary(y);
@@ -722,7 +722,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractImaginaryWithNegZeroReal() {
+ void testSubtractImaginaryWithNegZeroReal() {
final Complex x = Complex.ofCartesian(-0.0, 4.0);
final double y = 5.0;
final Complex z = x.subtractImaginary(y);
@@ -734,7 +734,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractFromReal() {
+ void testSubtractFromReal() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 5.0;
final Complex z = x.subtractFrom(y);
@@ -745,7 +745,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractFromRealNaN() {
+ void testSubtractFromRealNaN() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = nan;
final Complex z = x.subtractFrom(y);
@@ -756,7 +756,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractFromRealInf() {
+ void testSubtractFromRealInf() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = inf;
final Complex z = x.subtractFrom(y);
@@ -767,7 +767,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractFromRealWithPosZeroImaginary() {
+ void testSubtractFromRealWithPosZeroImaginary() {
final Complex x = Complex.ofCartesian(3.0, 0.0);
final double y = 5.0;
final Complex z = x.subtractFrom(y);
@@ -778,7 +778,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractFromImaginary() {
+ void testSubtractFromImaginary() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 5.0;
final Complex z = x.subtractFromImaginary(y);
@@ -789,7 +789,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractFromImaginaryNaN() {
+ void testSubtractFromImaginaryNaN() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = nan;
final Complex z = x.subtractFromImaginary(y);
@@ -800,7 +800,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractFromImaginaryInf() {
+ void testSubtractFromImaginaryInf() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = inf;
final Complex z = x.subtractFromImaginary(y);
@@ -811,7 +811,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractFromImaginaryWithPosZeroReal() {
+ void testSubtractFromImaginaryWithPosZeroReal() {
final Complex x = Complex.ofCartesian(0.0, 4.0);
final double y = 5.0;
final Complex z = x.subtractFromImaginary(y);
@@ -822,7 +822,7 @@ public class ComplexTest {
}
@Test
- public void testMultiply() {
+ void testMultiply() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final Complex y = Complex.ofCartesian(5.0, 6.0);
final Complex z = x.multiply(y);
@@ -831,7 +831,7 @@ public class ComplexTest {
}
@Test
- public void testMultiplyInfInf() {
+ void testMultiplyInfInf() {
final Complex z = infInf.multiply(infInf);
// Assert.assertTrue(z.isNaN()); // MATH-620
Assertions.assertTrue(z.isInfinite());
@@ -844,7 +844,7 @@ public class ComplexTest {
}
@Test
- public void testMultiplyReal() {
+ void testMultiplyReal() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 2.0;
Complex z = x.multiply(y);
@@ -861,7 +861,7 @@ public class ComplexTest {
}
@Test
- public void testMultiplyRealNaN() {
+ void testMultiplyRealNaN() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = nan;
final Complex z = x.multiply(y);
@@ -872,7 +872,7 @@ public class ComplexTest {
}
@Test
- public void testMultiplyRealInf() {
+ void testMultiplyRealInf() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = inf;
Complex z = x.multiply(y);
@@ -889,7 +889,7 @@ public class ComplexTest {
}
@Test
- public void testMultiplyRealZero() {
+ void testMultiplyRealZero() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 0.0;
Complex z = x.multiply(y);
@@ -908,7 +908,7 @@ public class ComplexTest {
}
@Test
- public void testMultiplyImaginary() {
+ void testMultiplyImaginary() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 2.0;
Complex z = x.multiplyImaginary(y);
@@ -925,7 +925,7 @@ public class ComplexTest {
}
@Test
- public void testMultiplyImaginaryNaN() {
+ void testMultiplyImaginaryNaN() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = nan;
final Complex z = x.multiplyImaginary(y);
@@ -936,7 +936,7 @@ public class ComplexTest {
}
@Test
- public void testMultiplyImaginaryInf() {
+ void testMultiplyImaginaryInf() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = inf;
Complex z = x.multiplyImaginary(y);
@@ -953,7 +953,7 @@ public class ComplexTest {
}
@Test
- public void testMultiplyImaginaryZero() {
+ void testMultiplyImaginaryZero() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 0.0;
Complex z = x.multiplyImaginary(y);
@@ -974,7 +974,7 @@ public class ComplexTest {
}
@Test
- public void testNonZeroMultiplyI() {
+ void testNonZeroMultiplyI() {
final double[] parts = {3.0, 4.0};
for (final double a : parts) {
for (final double b : parts) {
@@ -990,7 +990,7 @@ public class ComplexTest {
}
@Test
- public void testNonZeroMultiplyNegativeI() {
+ void testNonZeroMultiplyNegativeI() {
// This works no matter how you represent -I as a Complex
final double[] parts = {3.0, 4.0};
final Complex[] negIs = {Complex.ofCartesian(-0.0, -1), Complex.ofCartesian(0.0, -1)};
@@ -1010,7 +1010,7 @@ public class ComplexTest {
}
@Test
- public void testMultiplyZeroByI() {
+ void testMultiplyZeroByI() {
final double[] zeros = {-0.0, 0.0};
for (final double a : zeros) {
for (final double b : zeros) {
@@ -1035,7 +1035,7 @@ public class ComplexTest {
}
@Test
- public void testMultiplyZeroByNegativeI() {
+ void testMultiplyZeroByNegativeI() {
// Depending on how we represent -I this does not work for 2/4 cases
// but the cases are different. Here we test the negation of I.
final Complex negI = Complex.I.negate();
@@ -1072,7 +1072,7 @@ public class ComplexTest {
}
@Test
- public void testDivide() {
+ void testDivide() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final Complex y = Complex.ofCartesian(5.0, 6.0);
final Complex z = x.divide(y);
@@ -1081,28 +1081,28 @@ public class ComplexTest {
}
@Test
- public void testDivideZero() {
+ void testDivideZero() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final Complex z = x.divide(Complex.ZERO);
Assertions.assertEquals(INF, z);
}
@Test
- public void testDivideZeroZero() {
+ void testDivideZeroZero() {
final Complex x = Complex.ofCartesian(0.0, 0.0);
final Complex z = x.divide(Complex.ZERO);
Assertions.assertEquals(NAN, z);
}
@Test
- public void testDivideNaN() {
+ void testDivideNaN() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final Complex z = x.divide(NAN);
Assertions.assertTrue(z.isNaN());
}
@Test
- public void testDivideNanInf() {
+ void testDivideNanInf() {
Complex z = oneInf.divide(Complex.ONE);
Assertions.assertTrue(Double.isNaN(z.getReal()));
Assertions.assertEquals(inf, z.getImaginary(), 0);
@@ -1117,7 +1117,7 @@ public class ComplexTest {
}
@Test
- public void testDivideReal() {
+ void testDivideReal() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 2.0;
Complex z = x.divide(y);
@@ -1134,7 +1134,7 @@ public class ComplexTest {
}
@Test
- public void testDivideRealNaN() {
+ void testDivideRealNaN() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = nan;
final Complex z = x.divide(y);
@@ -1145,7 +1145,7 @@ public class ComplexTest {
}
@Test
- public void testDivideRealInf() {
+ void testDivideRealInf() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = inf;
Complex z = x.divide(y);
@@ -1162,7 +1162,7 @@ public class ComplexTest {
}
@Test
- public void testDivideRealZero() {
+ void testDivideRealZero() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 0.0;
Complex z = x.divide(y);
@@ -1179,7 +1179,7 @@ public class ComplexTest {
}
@Test
- public void testDivideImaginary() {
+ void testDivideImaginary() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 2.0;
Complex z = x.divideImaginary(y);
@@ -1196,7 +1196,7 @@ public class ComplexTest {
}
@Test
- public void testDivideImaginaryNaN() {
+ void testDivideImaginaryNaN() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = nan;
final Complex z = x.divideImaginary(y);
@@ -1207,7 +1207,7 @@ public class ComplexTest {
}
@Test
- public void testDivideImaginaryInf() {
+ void testDivideImaginaryInf() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = inf;
Complex z = x.divideImaginary(y);
@@ -1224,7 +1224,7 @@ public class ComplexTest {
}
@Test
- public void testDivideImaginaryZero() {
+ void testDivideImaginaryZero() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 0.0;
Complex z = x.divideImaginary(y);
@@ -1253,7 +1253,7 @@ public class ComplexTest {
* differences should be the sign of zero in certain cases.
*/
@Test
- public void testSignedArithmetic() {
+ void testSignedArithmetic() {
// The following lists the conditions for the double primitive operation where
// the Complex operation is different. Here the double argument can be:
// x : any value
@@ -1362,7 +1362,7 @@ public class ComplexTest {
* by zero using a Complex then multiplied by I.
*/
@Test
- public void testSignedDivideImaginaryArithmetic() {
+ void testSignedDivideImaginaryArithmetic() {
// Cases for divide by non-zero:
// 2: (-0.0,+x) / -y
// 4: (+x,+/-0.0) / -/+y
@@ -1414,7 +1414,7 @@ public class ComplexTest {
}
@Test
- public void testLog10() {
+ void testLog10() {
final double ln10 = Math.log(10);
final UniformRandomProvider rng = RandomSource.create(RandomSource.SPLIT_MIX_64);
for (int i = 0; i < 10; i++) {
@@ -1429,7 +1429,7 @@ public class ComplexTest {
}
@Test
- public void testPow() {
+ void testPow() {
final Complex x = Complex.ofCartesian(3, 4);
final double yDouble = 5.0;
final Complex yComplex = ofReal(yDouble);
@@ -1437,7 +1437,7 @@ public class ComplexTest {
}
@Test
- public void testPowComplexRealZero() {
+ void testPowComplexRealZero() {
// Hits the edge case when real == 0 but imaginary != 0
final Complex x = Complex.ofCartesian(0, 1);
final Complex z = Complex.ofCartesian(2, 3);
@@ -1448,7 +1448,7 @@ public class ComplexTest {
}
@Test
- public void testPowComplexZeroBase() {
+ void testPowComplexZeroBase() {
final double x = Double.MIN_VALUE;
assertPowComplexZeroBase(0, 0, NAN);
assertPowComplexZeroBase(0, x, NAN);
@@ -1463,7 +1463,7 @@ public class ComplexTest {
}
@Test
- public void testPowScalerRealZero() {
+ void testPowScalerRealZero() {
// Hits the edge case when real == 0 but imaginary != 0
final Complex x = Complex.ofCartesian(0, 1);
final Complex c = x.pow(2);
@@ -1473,7 +1473,7 @@ public class ComplexTest {
}
@Test
- public void testPowScalarZeroBase() {
+ void testPowScalarZeroBase() {
final double x = Double.MIN_VALUE;
assertPowScalarZeroBase(0, NAN);
assertPowScalarZeroBase(x, Complex.ZERO);
@@ -1485,7 +1485,7 @@ public class ComplexTest {
}
@Test
- public void testPowNanBase() {
+ void testPowNanBase() {
final Complex x = NAN;
final double yDouble = 5.0;
final Complex yComplex = ofReal(yDouble);
@@ -1493,7 +1493,7 @@ public class ComplexTest {
}
@Test
- public void testPowNanExponent() {
+ void testPowNanExponent() {
final Complex x = Complex.ofCartesian(3, 4);
final double yDouble = Double.NaN;
final Complex yComplex = ofReal(yDouble);
@@ -1501,7 +1501,7 @@ public class ComplexTest {
}
@Test
- public void testSqrtPolar() {
+ void testSqrtPolar() {
final double tol = 1e-12;
double r = 1;
for (int i = 0; i < 5; i++) {
@@ -1517,7 +1517,7 @@ public class ComplexTest {
}
@Test
- public void testZerothRootThrows() {
+ void testZerothRootThrows() {
final Complex c = Complex.ofCartesian(1, 1);
Assertions.assertThrows(IllegalArgumentException.class, () -> c.nthRoot(0),
"zeroth root should not be allowed");
@@ -1536,7 +1536,7 @@ public class ComplexTest {
* </pre>
*/
@Test
- public void testNthRootNormalThirdRoot() {
+ void testNthRootNormalThirdRoot() {
// The complex number we want to compute all third-roots for.
final Complex z = Complex.ofCartesian(-2, 2);
// The List holding all third roots
@@ -1568,7 +1568,7 @@ public class ComplexTest {
* </pre>
*/
@Test
- public void testNthRootNormalFourthRoot() {
+ void testNthRootNormalFourthRoot() {
// The complex number we want to compute all third-roots for.
final Complex z = Complex.ofCartesian(5, -2);
// The List holding all fourth roots
@@ -1602,7 +1602,7 @@ public class ComplexTest {
* </pre>
*/
@Test
- public void testNthRootCornercaseThirdRootImaginaryPartEmpty() {
+ void testNthRootCornercaseThirdRootImaginaryPartEmpty() {
// The number 8 has three third roots. One we all already know is the number 2.
// But there are two more complex roots.
final Complex z = Complex.ofCartesian(8, 0);
@@ -1634,7 +1634,7 @@ public class ComplexTest {
* </pre>
*/
@Test
- public void testNthRootCornercaseThirdRootRealPartZero() {
+ void testNthRootCornercaseThirdRootRealPartZero() {
// complex number with only imaginary part
final Complex z = Complex.ofCartesian(0, 2);
// The List holding all third roots
@@ -1668,7 +1668,7 @@ public class ComplexTest {
* </pre>
*/
@Test
- public void testNthRootNegativeArg() {
+ void testNthRootNegativeArg() {
// The complex number we want to compute all third-roots for.
final Complex z = Complex.ofCartesian(1, 0);
// The List holding all fourth roots
@@ -1702,7 +1702,7 @@ public class ComplexTest {
}
@Test
- public void testNthRootNan() {
+ void testNthRootNan() {
final int n = 3;
final Complex z = ofReal(Double.NaN);
final List<Complex> r = z.nthRoot(n);
@@ -1714,7 +1714,7 @@ public class ComplexTest {
}
@Test
- public void testNthRootInf() {
+ void testNthRootInf() {
final int n = 3;
final Complex z = ofReal(Double.NEGATIVE_INFINITY);
final List<Complex> r = z.nthRoot(n);
@@ -1722,39 +1722,39 @@ public class ComplexTest {
}
@Test
- public void testEqualsWithNull() {
+ void testEqualsWithNull() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
Assertions.assertFalse(x.equals(null));
}
@Test
- public void testEqualsWithAnotherClass() {
+ void testEqualsWithAnotherClass() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
Assertions.assertFalse(x.equals(new Object()));
}
@Test
- public void testEqualsWithSameObject() {
+ void testEqualsWithSameObject() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
Assertions.assertEquals(x, x);
}
@Test
- public void testEqualsWithCopyObject() {
+ void testEqualsWithCopyObject() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final Complex y = Complex.ofCartesian(3.0, 4.0);
Assertions.assertEquals(x, y);
}
@Test
- public void testEqualsWithRealDifference() {
+ void testEqualsWithRealDifference() {
final Complex x = Complex.ofCartesian(0.0, 0.0);
final Complex y = Complex.ofCartesian(0.0 + Double.MIN_VALUE, 0.0);
Assertions.assertNotEquals(x, y);
}
@Test
- public void testEqualsWithImaginaryDifference() {
+ void testEqualsWithImaginaryDifference() {
final Complex x = Complex.ofCartesian(0.0, 0.0);
final Complex y = Complex.ofCartesian(0.0, 0.0 + Double.MIN_VALUE);
Assertions.assertNotEquals(x, y);
@@ -1766,7 +1766,7 @@ public class ComplexTest {
* complex numbers.
*/
@Test
- public void testEqualsIsConsistentWithArraysEquals() {
+ void testEqualsIsConsistentWithArraysEquals() {
// Explicit check of the cases documented in the Javadoc:
assertEqualsIsConsistentWithArraysEquals(Complex.ofCartesian(Double.NaN, 0.0),
Complex.ofCartesian(Double.NaN, 1.0), "NaN real and different non-NaN imaginary");
@@ -1804,7 +1804,7 @@ public class ComplexTest {
* {@link Complex#isNaN()} are {@code false} for {@link Complex#equals(Object)}.
*/
@Test
- public void testEqualsWithDifferentNaNs() {
+ void testEqualsWithDifferentNaNs() {
// Test some NaN combinations
final double[] values = {Double.NaN, 0, 1};
final ArrayList<Complex> list = createCombinations(values);
@@ -1847,7 +1847,7 @@ public class ComplexTest {
* hash codes are {@code false} for {@link Object#equals(Object)}.
*/
@Test
- public void testHashCode() {
+ void testHashCode() {
// Test some values match Arrays.hashCode(double[])
final double[] values = {Double.NaN, Double.NEGATIVE_INFINITY, -3.45, -1, -0.0, 0.0, Double.MIN_VALUE, 1, 3.45,
Double.POSITIVE_INFINITY};
@@ -1900,7 +1900,7 @@ public class ComplexTest {
* href="https://issues.apache.org/jira/projects/MATH/issues/MATH-1118">MATH-1118</a>
*/
@Test
- public void testHashCodeWithDifferentZeros() {
+ void testHashCodeWithDifferentZeros() {
final double[] values = {-0.0, 0.0};
final ArrayList<Complex> list = createCombinations(values);
@@ -1951,7 +1951,7 @@ public class ComplexTest {
}
@Test
- public void testAtanhEdgeConditions() {
+ void testAtanhEdgeConditions() {
// Hits the edge case when imaginary == 0 but real != 0 or 1
final Complex c = Complex.ofCartesian(2, 0).atanh();
// Answer from g++
@@ -1960,7 +1960,7 @@ public class ComplexTest {
}
@Test
- public void testAtanhAssumptions() {
+ void testAtanhAssumptions() {
// Compute the same constants used by atanh
final double safeUpper = Math.sqrt(Double.MAX_VALUE) / 2;
final double safeLower = Math.sqrt(Double.MIN_NORMAL) * 2;
@@ -1990,7 +1990,7 @@ public class ComplexTest {
}
@Test
- public void testCoshSinhTanhAssumptions() {
+ void testCoshSinhTanhAssumptions() {
// Use the same constants used to approximate cosh/sinh with e^|x| / 2
final double safeExpMax = 708;
@@ -2042,7 +2042,7 @@ public class ComplexTest {
* of sin and cos together when |x| is small.
*/
@Test
- public void testSinCosLinearAssumptions() {
+ void testSinCosLinearAssumptions() {
// Are cos and sin linear around zero?
// If cos is still 1 then since d(sin) dx = cos then sin is linear.
Assertions.assertEquals(1.0, Math.cos(Double.MIN_NORMAL));
@@ -2065,7 +2065,7 @@ public class ComplexTest {
* different numbers.
*/
@Test
- public void testAbsVsSqrt() {
+ void testAbsVsSqrt() {
final UniformRandomProvider rng = RandomSource.create(RandomSource.XO_RO_SHI_RO_128_PP);
// Note: All methods implement scaling to ensure the magnitude can be computed.
// Try very large or small numbers that will over/underflow to test that the
@@ -2129,7 +2129,7 @@ public class ComplexTest {
* different numbers.
*/
@Test
- public void testAbsVsLog() {
+ void testAbsVsLog() {
final UniformRandomProvider rng = RandomSource.create(RandomSource.XO_RO_SHI_RO_128_PP);
// Note: All methods implement scaling to ensure the magnitude can be computed.
// Try very large or small numbers that will over/underflow to test that the
diff --git a/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/ArithmeticUtilsTest.java b/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/ArithmeticUtilsTest.java
index fbeb78e..a86ae4c 100644
--- a/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/ArithmeticUtilsTest.java
+++ b/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/ArithmeticUtilsTest.java
@@ -30,7 +30,7 @@ import org.junit.jupiter.api.Test;
public class ArithmeticUtilsTest {
@Test
- public void testGcd() {
+ void testGcd() {
int a = 30;
int b = 50;
int c = 77;
@@ -81,7 +81,7 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testGcdConsistency() {
+ void testGcdConsistency() {
// Use Integer to prevent varargs vs array issue with Arrays.asList
Integer[] primeList = {19, 23, 53, 67, 73, 79, 101, 103, 111, 131};
@@ -102,7 +102,7 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testGcdLong() {
+ void testGcdLong() {
long a = 30;
long b = 50;
long c = 77;
@@ -156,7 +156,7 @@ public class ArithmeticUtilsTest {
@Test
- public void testLcm() {
+ void testLcm() {
int a = 30;
int b = 50;
int c = 77;
@@ -203,7 +203,7 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testLcmLong() {
+ void testLcmLong() {
long a = 30;
long b = 50;
long c = 77;
@@ -254,7 +254,7 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testPow() {
+ void testPow() {
Assertions.assertEquals(1801088541, ArithmeticUtils.pow(21, 7));
Assertions.assertEquals(1, ArithmeticUtils.pow(21, 0));
@@ -322,14 +322,14 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testPowIntOverflow() {
+ void testPowIntOverflow() {
Assertions.assertThrows(ArithmeticException.class,
() -> ArithmeticUtils.pow(21, 8)
);
}
@Test
- public void testPowInt() {
+ void testPowInt() {
final int base = 21;
Assertions.assertEquals(85766121L,
@@ -339,14 +339,14 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testPowNegativeIntOverflow() {
+ void testPowNegativeIntOverflow() {
Assertions.assertThrows(ArithmeticException.class,
() -> ArithmeticUtils.pow(-21, 8)
);
}
@Test
- public void testPowNegativeInt() {
+ void testPowNegativeInt() {
final int base = -21;
Assertions.assertEquals(85766121,
@@ -356,7 +356,7 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testPowMinusOneInt() {
+ void testPowMinusOneInt() {
final int base = -1;
for (int i = 0; i < 100; i++) {
final int pow = ArithmeticUtils.pow(base, i);
@@ -365,7 +365,7 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testPowOneInt() {
+ void testPowOneInt() {
final int base = 1;
for (int i = 0; i < 100; i++) {
final int pow = ArithmeticUtils.pow(base, i);
@@ -374,14 +374,14 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testPowLongOverflow() {
+ void testPowLongOverflow() {
Assertions.assertThrows(ArithmeticException.class,
() -> ArithmeticUtils.pow(21, 15)
);
}
@Test
- public void testPowLong() {
+ void testPowLong() {
final long base = 21;
Assertions.assertEquals(154472377739119461L,
@@ -391,14 +391,14 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testPowNegativeLongOverflow() {
+ void testPowNegativeLongOverflow() {
Assertions.assertThrows(ArithmeticException.class,
() -> ArithmeticUtils.pow(-21L, 15)
);
}
@Test
- public void testPowNegativeLong() {
+ void testPowNegativeLong() {
final long base = -21;
Assertions.assertEquals(-154472377739119461L,
@@ -408,7 +408,7 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testPowMinusOneLong() {
+ void testPowMinusOneLong() {
final long base = -1;
for (int i = 0; i < 100; i++) {
final long pow = ArithmeticUtils.pow(base, i);
@@ -417,7 +417,7 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testPowOneLong() {
+ void testPowOneLong() {
final long base = 1;
for (int i = 0; i < 100; i++) {
final long pow = ArithmeticUtils.pow(base, i);
@@ -426,7 +426,7 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testIsPowerOfTwo() {
+ void testIsPowerOfTwo() {
final int n = 1025;
final boolean[] expected = new boolean[n];
Arrays.fill(expected, false);
@@ -533,13 +533,13 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testRemainderUnsignedInt() {
+ void testRemainderUnsignedInt() {
Assertions.assertEquals(36, ArithmeticUtils.remainderUnsigned(-2147479015, 63));
Assertions.assertEquals(6, ArithmeticUtils.remainderUnsigned(-2147479015, 25));
}
@Test
- public void testRemainderUnsignedIntSpecialCases() {
+ void testRemainderUnsignedIntSpecialCases() {
int[] ints = getIntSpecialCases();
for (int dividend : ints) {
for (int divisor : ints) {
@@ -555,12 +555,12 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testRemainderUnsignedLong() {
+ void testRemainderUnsignedLong() {
Assertions.assertEquals(48L, ArithmeticUtils.remainderUnsigned(-2147479015L, 63L));
}
@Test
- public void testRemainderUnsignedLongSpecialCases() {
+ void testRemainderUnsignedLongSpecialCases() {
long[] longs = getLongSpecialCases();
for (long dividend : longs) {
for (long divisor : longs) {
@@ -579,7 +579,7 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testDivideUnsignedInt() {
+ void testDivideUnsignedInt() {
Assertions.assertEquals(34087115, ArithmeticUtils.divideUnsigned(-2147479015, 63));
Assertions.assertEquals(85899531, ArithmeticUtils.divideUnsigned(-2147479015, 25));
Assertions.assertEquals(2147483646, ArithmeticUtils.divideUnsigned(-3, 2));
@@ -593,7 +593,7 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testDivideUnsignedIntSpecialCases() {
+ void testDivideUnsignedIntSpecialCases() {
int[] ints = getIntSpecialCases();
for (int dividend : ints) {
for (int divisor : ints) {
@@ -609,12 +609,12 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testDivideUnsignedLong() {
+ void testDivideUnsignedLong() {
Assertions.assertEquals(292805461453366231L, ArithmeticUtils.divideUnsigned(-2147479015L, 63L));
}
@Test
- public void testDivideUnsignedLongSpecialCases() {
+ void testDivideUnsignedLongSpecialCases() {
long[] longs = getLongSpecialCases();
for (long dividend : longs) {
for (long divisor : longs) {
diff --git a/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/PrecisionTest.java b/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/PrecisionTest.java
index 92e193f..94e8ca4 100644
--- a/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/PrecisionTest.java
+++ b/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/PrecisionTest.java
@@ -50,7 +50,7 @@ public class PrecisionTest {
}
@Test
- public void testEqualsWithRelativeTolerance() {
+ void testEqualsWithRelativeTolerance() {
Assertions.assertTrue(Precision.equalsWithRelativeTolerance(0d, 0d, 0d));
Assertions.assertTrue(Precision.equalsWithRelativeTolerance(0d, 1 / Double.NEGATIVE_INFINITY, 0d));
@@ -77,7 +77,7 @@ public class PrecisionTest {
}
@Test
- public void testEqualsIncludingNaN() {
+ void testEqualsIncludingNaN() {
double[] testArray = {
Double.NaN,
Double.POSITIVE_INFINITY,
@@ -98,12 +98,12 @@ public class PrecisionTest {
}
@Test
- public void testEqualsWithAllowedDelta() {
+ void testEqualsWithAllowedDelta() {
assertEqualsWithAllowedDelta(Precision::equalsIncludingNaN, true);
}
@Test
- public void testEqualsIncludingNaNWithAllowedDelta() {
+ void testEqualsIncludingNaNWithAllowedDelta() {
assertEqualsWithAllowedDelta(Precision::equalsIncludingNaN, true);
}
@@ -120,18 +120,18 @@ public class PrecisionTest {
}
@Test
- public void testEqualsWithAllowedUlps() {
+ void testEqualsWithAllowedUlps() {
assertEqualsIncludingNaNWithAllowedUlps(Precision::equals, false, false);
}
@Test
- public void testEqualsWithImplicitAllowedUlpsOf1() {
+ void testEqualsWithImplicitAllowedUlpsOf1() {
// Use the version without the ulp argument
assertEqualsIncludingNaNWithAllowedUlps((a, b, ulp) -> Precision.equals(a, b), false, true);
}
@Test
- public void testEqualsIncludingNaNWithAllowedUlps() {
+ void testEqualsIncludingNaNWithAllowedUlps() {
assertEqualsIncludingNaNWithAllowedUlps(Precision::equalsIncludingNaN, true, false);
}
@@ -176,7 +176,7 @@ public class PrecisionTest {
// converted to float
@Test
- public void testFloatEqualsIncludingNaN() {
+ void testFloatEqualsIncludingNaN() {
float[] testArray = {
Float.NaN,
Float.POSITIVE_INFINITY,
@@ -197,12 +197,12 @@ public class PrecisionTest {
}
@Test
- public void testFloatEqualsWithAllowedDelta() {
+ void testFloatEqualsWithAllowedDelta() {
assertFloatEqualsWithAllowedDelta(Precision::equalsIncludingNaN, true);
}
@Test
- public void testFloatEqualsIncludingNaNWithAllowedDelta() {
+ void testFloatEqualsIncludingNaNWithAllowedDelta() {
assertFloatEqualsWithAllowedDelta(Precision::equalsIncludingNaN, true);
}
@@ -219,18 +219,18 @@ public class PrecisionTest {
}
@Test
- public void testFloatEqualsWithAllowedUlps() {
+ void testFloatEqualsWithAllowedUlps() {
assertFloatEqualsIncludingNaNWithAllowedUlps(Precision::equals, false, false);
}
@Test
- public void testFloatEqualsWithImplicitAllowedUlpsOf1() {
+ void testFloatEqualsWithImplicitAllowedUlpsOf1() {
// Use the version without the ulp argument
assertFloatEqualsIncludingNaNWithAllowedUlps((a, b, ulp) -> Precision.equals(a, b), false, true);
}
@Test
- public void testFloatEqualsIncludingNaNWithAllowedUlps() {
+ void testFloatEqualsIncludingNaNWithAllowedUlps() {
assertFloatEqualsIncludingNaNWithAllowedUlps(Precision::equalsIncludingNaN, true, false);
}
@@ -272,7 +272,7 @@ public class PrecisionTest {
}
@Test
- public void testCompareToEpsilon() {
+ void testCompareToEpsilon() {
Assertions.assertEquals(0, Precision.compareTo(152.33, 152.32, .011));
Assertions.assertTrue(Precision.compareTo(152.308, 152.32, .011) < 0);
Assertions.assertTrue(Precision.compareTo(152.33, 152.318, .011) > 0);
@@ -281,7 +281,7 @@ public class PrecisionTest {
}
@Test
- public void testCompareToMaxUlps() {
+ void testCompareToMaxUlps() {
double a = 152.32;
double delta = Math.ulp(a);
for (int i = 0; i <= 10; ++i) {
@@ -318,7 +318,7 @@ public class PrecisionTest {
}
@Test
- public void testRoundDouble() {
+ void testRoundDouble() {
double x = 1.234567890;
Assertions.assertEquals(1.23, Precision.round(x, 2), 0.0);
Assertions.assertEquals(1.235, Precision.round(x, 3), 0.0);
@@ -423,7 +423,7 @@ public class PrecisionTest {
}
@Test
- public void testRepresentableDelta() {
+ void testRepresentableDelta() {
int nonRepresentableCount = 0;
final double x = 100;
final int numTrials = 10000;
@@ -439,13 +439,13 @@ public class PrecisionTest {
}
@Test
- public void testIssue721() {
+ void testIssue721() {
Assertions.assertEquals(-53, Math.getExponent(Precision.EPSILON));
Assertions.assertEquals(-1022, Math.getExponent(Precision.SAFE_MIN));
}
@Test
- public void testMath475() {
+ void testMath475() {
final double a = 1.7976931348623182E16;
final double b = Math.nextUp(a);
@@ -464,7 +464,7 @@ public class PrecisionTest {
}
@Test
- public void testMath475Float() {
+ void testMath475Float() {
final float a = 1.7976931348623182E16f;
final float b = Math.nextUp(a);
@@ -483,7 +483,7 @@ public class PrecisionTest {
}
@Test
- public void testMath843() {
+ void testMath843() {
final double afterEpsilon = Math.nextAfter(Precision.EPSILON,
Double.POSITIVE_INFINITY);
@@ -495,7 +495,7 @@ public class PrecisionTest {
}
@Test
- public void testMath1127() {
+ void testMath1127() {
Assertions.assertFalse(Precision.equals(2.0, -2.0, 1));
Assertions.assertTrue(Precision.equals(0.0, -0.0, 0));
Assertions.assertFalse(Precision.equals(2.0f, -2.0f, 1));
diff --git a/commons-numbers-examples/examples-jmh/src/test/java/org/apache/commons/numbers/examples/jmh/arrays/DoublePrecisionTest.java b/commons-numbers-examples/examples-jmh/src/test/java/org/apache/commons/numbers/examples/jmh/arrays/DoublePrecisionTest.java
index deda670..d48c5a0 100644
--- a/commons-numbers-examples/examples-jmh/src/test/java/org/apache/commons/numbers/examples/jmh/arrays/DoublePrecisionTest.java
+++ b/commons-numbers-examples/examples-jmh/src/test/java/org/apache/commons/numbers/examples/jmh/arrays/DoublePrecisionTest.java
@@ -24,7 +24,7 @@ import org.junit.jupiter.api.Test;
*/
public class DoublePrecisionTest {
@Test
- public void testSplitAssumptions() {
+ void testSplitAssumptions() {
// The multiplier used to split the double value into high and low parts.
final double scale = (1 << 27) + 1;
// The upper limit above which a number may overflow during the split into a high part.
@@ -40,7 +40,7 @@ public class DoublePrecisionTest {
}
@Test
- public void testHighPart() {
+ void testHighPart() {
Assertions.assertEquals(Double.NaN, DoublePrecision.highPart(Double.POSITIVE_INFINITY));
Assertions.assertEquals(Double.NaN, DoublePrecision.highPart(Double.NEGATIVE_INFINITY));
Assertions.assertEquals(Double.NaN, DoublePrecision.highPart(Double.NaN));
@@ -50,7 +50,7 @@ public class DoublePrecisionTest {
}
@Test
- public void testHighPartUnscaled() {
+ void testHighPartUnscaled() {
Assertions.assertEquals(Double.NaN, DoublePrecision.highPartUnscaled(Double.POSITIVE_INFINITY));
Assertions.assertEquals(Double.NaN, DoublePrecision.highPartUnscaled(Double.NEGATIVE_INFINITY));
Assertions.assertEquals(Double.NaN, DoublePrecision.highPartUnscaled(Double.NaN));
@@ -64,7 +64,7 @@ public class DoublePrecisionTest {
* result as JDK 9 Math.fma(x, y, -x * y) for edge cases.
*/
@Test
- public void testProductLow() {
+ void testProductLow() {
assertProductLow(0.0, 1.0, Math.nextDown(Double.MIN_NORMAL));
assertProductLow(0.0, -1.0, Math.nextDown(Double.MIN_NORMAL));
assertProductLow(Double.NaN, 1.0, Double.POSITIVE_INFINITY);
@@ -79,7 +79,7 @@ public class DoublePrecisionTest {
}
@Test
- public void testIsNotNormal() {
+ void testIsNotNormal() {
for (double a : new double[] {Double.MAX_VALUE, 1.0, Double.MIN_NORMAL}) {
Assertions.assertFalse(DoublePrecision.isNotNormal(a));
Assertions.assertFalse(DoublePrecision.isNotNormal(-a));
diff --git a/commons-numbers-examples/examples-jmh/src/test/java/org/apache/commons/numbers/examples/jmh/arrays/LinearCombinationsTest.java b/commons-numbers-examples/examples-jmh/src/test/java/org/apache/commons/numbers/examples/jmh/arrays/LinearCombinationsTest.java
index f2c99d1..d0bccb3 100644
--- a/commons-numbers-examples/examples-jmh/src/test/java/org/apache/commons/numbers/examples/jmh/arrays/LinearCombinationsTest.java
+++ b/commons-numbers-examples/examples-jmh/src/test/java/org/apache/commons/numbers/examples/jmh/arrays/LinearCombinationsTest.java
@@ -359,7 +359,7 @@ public class LinearCombinationsTest {
* greater in magnitude than the the original number due to round-off in the split.
*/
@Test
- public void testOverflow() {
+ void testOverflow() {
// Create a simple dot product that is different in high precision and has
// values that create a high part above the original number. This can be done using
// a mantissa with almost all bits set to 1.
@@ -423,7 +423,7 @@ public class LinearCombinationsTest {
* This case is derived from computations on a complex cis number.
*/
@Test
- public void testCisNumber() {
+ void testCisNumber() {
final double theta = 5.992112452678286E-7;
final double x = Math.cos(theta);
final double y = Math.sin(theta);
@@ -439,7 +439,7 @@ public class LinearCombinationsTest {
* round-off sum in single or 2-fold precision.
*/
@Test
- public void testSumZero() {
+ void testSumZero() {
// Fixed seed for stability
final UniformRandomProvider rng = RandomSource.create(RandomSource.XO_RO_SHI_RO_128_PP, 876543L);
final int size = 10;
@@ -569,7 +569,7 @@ public class LinearCombinationsTest {
* Test the clip method does what it specifies.
*/
@Test
- public void testClip() {
+ void testClip() {
// min value is not affected
Assertions.assertEquals(Double.MIN_VALUE, clip(MIN).doubleValue());
Assertions.assertEquals(-Double.MIN_VALUE, clip(MIN.negate()).doubleValue());
diff --git a/commons-numbers-field/src/test/java/org/apache/commons/numbers/field/FP64Test.java b/commons-numbers-field/src/test/java/org/apache/commons/numbers/field/FP64Test.java
index 260ecc7..6291667 100644
--- a/commons-numbers-field/src/test/java/org/apache/commons/numbers/field/FP64Test.java
+++ b/commons-numbers-field/src/test/java/org/apache/commons/numbers/field/FP64Test.java
@@ -24,7 +24,7 @@ import org.junit.jupiter.api.Test;
*/
public class FP64Test {
@Test
- public void testConsistencyWithDouble() {
+ void testConsistencyWithDouble() {
final double v = -5.67e89;
final Double a = Double.valueOf(v);
final FP64 b = FP64.of(v);
@@ -38,7 +38,7 @@ public class FP64Test {
}
@Test
- public void testEquals() {
+ void testEquals() {
final FP64 a = FP64.of(1.23);
final FP64 b = FP64.of(4.56);
@@ -54,23 +54,23 @@ public class FP64Test {
}
@Test
- public void testOne() {
+ void testOne() {
Assertions.assertEquals(1d, FP64.of(-3.4).one().doubleValue(), 0d);
}
@Test
- public void testZero() {
+ void testZero() {
Assertions.assertEquals(0d, FP64.of(-3.4).zero().doubleValue(), 0d);
}
@Test
- public void testSubtract() {
+ void testSubtract() {
final double a = 123.4;
final double b = 5678.9;
Assertions.assertEquals(a - b, FP64.of(a).subtract(FP64.of(b)).doubleValue(), 0d);
}
@Test
- public void testDivide() {
+ void testDivide() {
final double a = 123.4;
final double b = 5678.9;
@@ -78,7 +78,7 @@ public class FP64Test {
}
@Test
- public void testMultiplyInt() {
+ void testMultiplyInt() {
final double a = 123.4;
final int n = 3456789;
@@ -86,19 +86,19 @@ public class FP64Test {
}
@Test
- public void testPowInt() {
+ void testPowInt() {
final double a = 123.4;
final int n = 5;
Assertions.assertEquals(Math.pow(a, n), FP64.of(a).pow(n).doubleValue(), 0d);
}
@Test
- public void testZeroPow() {
+ void testZeroPow() {
Assertions.assertSame(FP64.of(9876.5).one(), FP64.of(2.3456).pow(0));
}
@Test
- public void testCompare() {
+ void testCompare() {
Assertions.assertTrue(FP64.of(0).compareTo(FP64.of(-1)) > 0);
Assertions.assertTrue(FP64.of(1).compareTo(FP64.of(2)) < 0);
diff --git a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/BigFractionTest.java b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/BigFractionTest.java
index f0bcd27..a457767 100644
--- a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/BigFractionTest.java
+++ b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/BigFractionTest.java
@@ -69,7 +69,7 @@ public class BigFractionTest {
}
@Test
- public void testConstructor() {
+ void testConstructor() {
for (final CommonTestCases.UnaryOperatorTestCase testCase : CommonTestCases.numDenConstructorTestCases()) {
assertFraction(
testCase.expectedNumerator,
@@ -97,7 +97,7 @@ public class BigFractionTest {
}
@Test
- public void testConstructorZero() {
+ void testConstructorZero() {
Assertions.assertSame(BigFraction.ZERO, BigFraction.from(0.0));
Assertions.assertSame(BigFraction.ZERO, BigFraction.from(0.0, 1e-10, 100));
Assertions.assertSame(BigFraction.ZERO, BigFraction.from(0.0, 100));
@@ -114,7 +114,7 @@ public class BigFractionTest {
// MATH-179
@Test
- public void testDoubleConstructor() throws Exception {
+ void testDoubleConstructor() throws Exception {
for (final CommonTestCases.DoubleToFractionTestCase testCase : CommonTestCases.doubleConstructorTestCases()) {
assertFraction(
testCase.expectedNumerator,
@@ -148,7 +148,7 @@ public class BigFractionTest {
// MATH-181
// NUMBERS-147
@Test
- public void testDoubleConstructorWithMaxDenominator() throws Exception {
+ void testDoubleConstructorWithMaxDenominator() throws Exception {
for (final CommonTestCases.DoubleToFractionTestCase testCase : CommonTestCases.doubleMaxDenomConstructorTestCases()) {
assertFraction(
testCase.expectedNumerator,
@@ -168,7 +168,7 @@ public class BigFractionTest {
}
@Test
- public void testDoubleConstructorThrows() {
+ void testDoubleConstructorThrows() {
final double eps = 1e-5;
final int maxIterations = Integer.MAX_VALUE;
final int maxDenominator = Integer.MAX_VALUE;
@@ -185,7 +185,7 @@ public class BigFractionTest {
}
@Test
- public void testDoubleConstructorGoldenRatioThrows() {
+ void testDoubleConstructorGoldenRatioThrows() {
// the golden ratio is notoriously a difficult number for continuous fraction
Assertions.assertThrows(FractionException.class,
() -> BigFraction.from((1 + Math.sqrt(5)) / 2, 1.0e-12, 25)
@@ -194,7 +194,7 @@ public class BigFractionTest {
// MATH-1029
@Test
- public void testDoubleConstructorWithMaxDenominatorOverFlow() {
+ void testDoubleConstructorWithMaxDenominatorOverFlow() {
Assertions.assertThrows(ArithmeticException.class,
() -> BigFraction.from(1e10, 1000)
);
@@ -204,7 +204,7 @@ public class BigFractionTest {
}
@Test
- public void testDoubleConstructorOverflow() {
+ void testDoubleConstructorOverflow() {
assertDoubleConstructorOverflow(0.75000000001455192);
assertDoubleConstructorOverflow(1.0e10);
assertDoubleConstructorOverflow(-1.0e10);
@@ -218,7 +218,7 @@ public class BigFractionTest {
}
@Test
- public void testDoubleConstructorWithEpsilonLimit() throws Exception {
+ void testDoubleConstructorWithEpsilonLimit() throws Exception {
assertFraction(2, 5, BigFraction.from(0.4, 1.0e-5, 100));
assertFraction(3, 5, BigFraction.from(0.6152, 0.02, 100));
@@ -230,7 +230,7 @@ public class BigFractionTest {
}
@Test
- public void testCompareTo() {
+ void testCompareTo() {
final BigFraction a = BigFraction.of(1, 2);
final BigFraction b = BigFraction.of(1, 3);
final BigFraction c = BigFraction.of(1, 2);
@@ -272,7 +272,7 @@ public class BigFractionTest {
}
@Test
- public void testDoubleValue() {
+ void testDoubleValue() {
assertDoubleValue(0.5, 1, 2);
assertDoubleValue(-0.5, -1, 2);
assertDoubleValue(-0.5, 1, -2);
@@ -303,7 +303,7 @@ public class BigFractionTest {
}
@Test
- public void testDoubleValueForSubnormalNumbers() {
+ void testDoubleValueForSubnormalNumbers() {
assertDoubleValue(
//Double.MIN_VALUE * 2/3
Double.MIN_VALUE,
@@ -347,7 +347,7 @@ public class BigFractionTest {
}
@Test
- public void testDoubleValueForInfinities() {
+ void testDoubleValueForInfinities() {
//the smallest integer that rounds up to Double.POSITIVE_INFINITY
final BigInteger minInf = BigInteger.ONE
.shiftLeft(1024)
@@ -367,7 +367,7 @@ public class BigFractionTest {
// MATH-744
@Test
- public void testDoubleValueForLargeNumeratorAndDenominator() {
+ void testDoubleValueForLargeNumeratorAndDenominator() {
final BigInteger pow400 = BigInteger.TEN.pow(400);
final BigInteger pow401 = BigInteger.TEN.pow(401);
final BigInteger two = new BigInteger("2");
@@ -379,7 +379,7 @@ public class BigFractionTest {
// MATH-744
@Test
- public void testFloatValueForLargeNumeratorAndDenominator() {
+ void testFloatValueForLargeNumeratorAndDenominator() {
final BigInteger pow400 = BigInteger.TEN.pow(400);
final BigInteger pow401 = BigInteger.TEN.pow(401);
final BigInteger two = new BigInteger("2");
@@ -390,7 +390,7 @@ public class BigFractionTest {
}
@Test
- public void testDoubleValueForLargeNumeratorAndSmallDenominator() {
+ void testDoubleValueForLargeNumeratorAndSmallDenominator() {
// NUMBERS-15
final BigInteger pow300 = BigInteger.TEN.pow(300);
final BigInteger pow330 = BigInteger.TEN.pow(330);
@@ -421,7 +421,7 @@ public class BigFractionTest {
// NUMBERS-15
@Test
- public void testFloatValueForLargeNumeratorAndSmallDenominator() {
+ void testFloatValueForLargeNumeratorAndSmallDenominator() {
final BigInteger pow30 = BigInteger.TEN.pow(30);
final BigInteger pow40 = BigInteger.TEN.pow(40);
final BigFraction large = BigFraction.of(pow40.add(BigInteger.ONE),
@@ -431,7 +431,7 @@ public class BigFractionTest {
}
@Test
- public void testFloatValue() {
+ void testFloatValue() {
Assertions.assertEquals(0.5f, BigFraction.of(1, 2).floatValue());
Assertions.assertEquals(0.5f, BigFraction.of(-1, -2).floatValue());
Assertions.assertEquals(-0.5f, BigFraction.of(-1, 2).floatValue());
@@ -448,7 +448,7 @@ public class BigFractionTest {
}
@Test
- public void testIntValue() {
+ void testIntValue() {
Assertions.assertEquals(0, BigFraction.of(1, 2).intValue());
Assertions.assertEquals(0, BigFraction.of(-1, -2).intValue());
Assertions.assertEquals(0, BigFraction.of(-1, 2).intValue());
@@ -464,7 +464,7 @@ public class BigFractionTest {
}
@Test
- public void testLongValue() {
+ void testLongValue() {
Assertions.assertEquals(0L, BigFraction.of(1, 2).longValue());
Assertions.assertEquals(0L, BigFraction.of(-1, -2).longValue());
Assertions.assertEquals(0L, BigFraction.of(-1, 2).longValue());
@@ -480,7 +480,7 @@ public class BigFractionTest {
}
@Test
- public void testBigDecimalValue() {
+ void testBigDecimalValue() {
Assertions.assertEquals(new BigDecimal(0.5), BigFraction.of(1, 2).bigDecimalValue());
Assertions.assertEquals(new BigDecimal("0.0003"), BigFraction.of(3, 10000).bigDecimalValue());
Assertions.assertEquals(new BigDecimal("0"), BigFraction.of(1, 3).bigDecimalValue(RoundingMode.DOWN));
@@ -488,7 +488,7 @@ public class BigFractionTest {
}
@Test
- public void testAbs() {
+ void testAbs() {
for (final CommonTestCases.UnaryOperatorTestCase testCase : CommonTestCases.absTestCases()) {
final BigFraction f = BigFraction.of(testCase.operandNumerator, testCase.operandDenominator);
assertFraction(testCase.expectedNumerator, testCase.expectedDenominator, f.abs());
@@ -496,7 +496,7 @@ public class BigFractionTest {
}
@Test
- public void testReciprocal() {
+ void testReciprocal() {
for (final CommonTestCases.UnaryOperatorTestCase testCase : CommonTestCases.reciprocalTestCases()) {
final BigFraction f = BigFraction.of(testCase.operandNumerator, testCase.operandDenominator);
assertFraction(testCase.expectedNumerator, testCase.expectedDenominator, f.reciprocal());
@@ -507,7 +507,7 @@ public class BigFractionTest {
}
@Test
- public void testNegate() {
+ void testNegate() {
for (final CommonTestCases.UnaryOperatorTestCase testCase : CommonTestCases.negateTestCases()) {
final BigFraction f = BigFraction.of(testCase.operandNumerator, testCase.operandDenominator);
assertFraction(testCase.expectedNumerator, testCase.expectedDenominator, f.negate());
@@ -515,7 +515,7 @@ public class BigFractionTest {
}
@Test
- public void testAdd() {
+ void testAdd() {
for (final CommonTestCases.BinaryOperatorTestCase testCase : CommonTestCases.addFractionTestCases()) {
final BigFraction f1 = BigFraction.of(testCase.firstOperandNumerator, testCase.firstOperandDenominator);
final BigFraction f2 = BigFraction.of(testCase.secondOperandNumerator, testCase.secondOperandDenominator);
@@ -539,7 +539,7 @@ public class BigFractionTest {
}
@Test
- public void testDivide() {
+ void testDivide() {
for (final CommonTestCases.BinaryOperatorTestCase testCase : CommonTestCases.divideByFractionTestCases()) {
final BigFraction f1 = BigFraction.of(testCase.firstOperandNumerator, testCase.firstOperandDenominator);
final BigFraction f2 = BigFraction.of(testCase.secondOperandNumerator, testCase.secondOperandDenominator);
@@ -569,7 +569,7 @@ public class BigFractionTest {
}
@Test
- public void testMultiply() {
+ void testMultiply() {
for (final CommonTestCases.BinaryOperatorTestCase testCase : CommonTestCases.multiplyByFractionTestCases()) {
final BigFraction f1 = BigFraction.of(testCase.firstOperandNumerator, testCase.firstOperandDenominator);
final BigFraction f2 = BigFraction.of(testCase.secondOperandNumerator, testCase.secondOperandDenominator);
@@ -588,7 +588,7 @@ public class BigFractionTest {
}
@Test
- public void testPow() {
+ void testPow() {
for (final CommonTestCases.BinaryIntOperatorTestCase testCase : CommonTestCases.powTestCases()) {
final BigFraction f1 = BigFraction.of(testCase.firstOperandNumerator, testCase.firstOperandDenominator);
final int exponent = testCase.secondOperand;
@@ -604,7 +604,7 @@ public class BigFractionTest {
}
@Test
- public void testSubtract() {
+ void testSubtract() {
for (final CommonTestCases.BinaryOperatorTestCase testCase : CommonTestCases.subtractFractionTestCases()) {
final BigFraction f1 = BigFraction.of(testCase.firstOperandNumerator, testCase.firstOperandDenominator);
final BigFraction f2 = BigFraction.of(testCase.secondOperandNumerator, testCase.secondOperandDenominator);
@@ -623,7 +623,7 @@ public class BigFractionTest {
}
@Test
- public void testEqualsAndHashCode() {
+ void testEqualsAndHashCode() {
final BigFraction zero = BigFraction.of(0, 1);
Assertions.assertEquals(zero, zero);
Assertions.assertFalse(zero.equals(null));
@@ -685,17 +685,17 @@ public class BigFractionTest {
}
@Test
- public void testAdditiveNeutral() {
+ void testAdditiveNeutral() {
Assertions.assertEquals(BigFraction.ZERO, BigFraction.ONE.zero());
}
@Test
- public void testMultiplicativeNeutral() {
+ void testMultiplicativeNeutral() {
Assertions.assertEquals(BigFraction.ONE, BigFraction.ZERO.one());
}
@Test
- public void testSerial() {
+ void testSerial() {
final BigFraction[] fractions = {
BigFraction.of(3, 4), BigFraction.ONE, BigFraction.ZERO,
BigFraction.of(17), BigFraction.from(Math.PI, 1000),
@@ -708,7 +708,7 @@ public class BigFractionTest {
}
@Test
- public void testToString() {
+ void testToString() {
Assertions.assertEquals("0", BigFraction.of(0, 3).toString());
Assertions.assertEquals("0", BigFraction.of(0, -3).toString());
Assertions.assertEquals("3", BigFraction.of(6, 2).toString());
@@ -718,7 +718,7 @@ public class BigFractionTest {
}
@Test
- public void testParse() {
+ void testParse() {
final String[] validExpressions = new String[] {
"1 / 2",
"-1 / 2",
@@ -770,7 +770,7 @@ public class BigFractionTest {
}
@Test
- public void testMath340() {
+ void testMath340() {
final BigFraction fractionA = BigFraction.from(0.00131);
final BigFraction fractionB = BigFraction.from(.37).reciprocal();
final BigFraction errorResult = fractionA.multiply(fractionB);
diff --git a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/ContinuedFractionTest.java b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/ContinuedFractionTest.java
index 6760894..af2f180 100644
--- a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/ContinuedFractionTest.java
+++ b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/ContinuedFractionTest.java
@@ -26,7 +26,7 @@ import org.junit.jupiter.api.Test;
public class ContinuedFractionTest {
@Test
- public void testGoldenRatio() throws Exception {
+ void testGoldenRatio() throws Exception {
ContinuedFraction cf = new ContinuedFraction() {
@Override
public double getA(int n, double x) {
@@ -45,7 +45,7 @@ public class ContinuedFractionTest {
}
@Test
- public void test415Over93() throws Exception {
+ void test415Over93() throws Exception {
// https://en.wikipedia.org/wiki/Continued_fraction
// 415 1
// --- = 4 + ---------
@@ -80,7 +80,7 @@ public class ContinuedFractionTest {
}
@Test
- public void testMaxIterationsThrows() throws Exception {
+ void testMaxIterationsThrows() throws Exception {
ContinuedFraction cf = new ContinuedFraction() {
@Override
public double getA(int n, double x) {
@@ -101,7 +101,7 @@ public class ContinuedFractionTest {
}
@Test
- public void testNaNThrows() throws Exception {
+ void testNaNThrows() throws Exception {
// Create a NaN during the iteration
ContinuedFraction cf = new ContinuedFraction() {
@Override
@@ -122,7 +122,7 @@ public class ContinuedFractionTest {
}
@Test
- public void testInfThrows() throws Exception {
+ void testInfThrows() throws Exception {
// Create an infinity during the iteration:
// a / cPrev => a_1 / b_0 => Double.MAX_VALUE / 0.5
ContinuedFraction cf = new ContinuedFraction() {
@@ -150,7 +150,7 @@ public class ContinuedFractionTest {
// NUMBERS-46
@Test
- public void testOneIteration() {
+ void testOneIteration() {
ContinuedFraction cf = new ContinuedFraction() {
@Override
public double getA(int n, double x) {
@@ -170,7 +170,7 @@ public class ContinuedFractionTest {
// NUMBERS-46
@Test
- public void testTwoIterations() {
+ void testTwoIterations() {
ContinuedFraction cf = new ContinuedFraction() {
@Override
public double getA(int n, double x) {
diff --git a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionTest.java b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionTest.java
index f26a616..0c5bc3e 100644
--- a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionTest.java
+++ b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionTest.java
@@ -49,7 +49,7 @@ public class FractionTest {
}
@Test
- public void testConstructor() {
+ void testConstructor() {
for (final CommonTestCases.UnaryOperatorTestCase testCase : CommonTestCases.numDenConstructorTestCases()) {
assertFraction(
testCase.expectedNumerator,
@@ -69,7 +69,7 @@ public class FractionTest {
}
@Test
- public void testConstructorZero() {
+ void testConstructorZero() {
Assertions.assertSame(Fraction.ZERO, Fraction.from(0.0));
Assertions.assertSame(Fraction.ZERO, Fraction.from(0.0, 1e-10, 100));
Assertions.assertSame(Fraction.ZERO, Fraction.from(0.0, 100));
@@ -80,7 +80,7 @@ public class FractionTest {
// MATH-179
@Test
- public void testDoubleConstructor() throws Exception {
+ void testDoubleConstructor() throws Exception {
for (final CommonTestCases.DoubleToFractionTestCase testCase : CommonTestCases.doubleConstructorTestCases()) {
assertFraction(
testCase.expectedNumerator,
@@ -101,7 +101,7 @@ public class FractionTest {
// MATH-181
// NUMBERS-147
@Test
- public void testDoubleConstructorWithMaxDenominator() throws Exception {
+ void testDoubleConstructorWithMaxDenominator() throws Exception {
for (final CommonTestCases.DoubleToFractionTestCase testCase : CommonTestCases.doubleMaxDenomConstructorTestCases()) {
assertFraction(
testCase.expectedNumerator,
@@ -120,7 +120,7 @@ public class FractionTest {
}
@Test
- public void testDoubleConstructorThrows() {
+ void testDoubleConstructorThrows() {
final double eps = 1e-5;
final int maxIterations = Integer.MAX_VALUE;
final int maxDenominator = Integer.MAX_VALUE;
@@ -137,7 +137,7 @@ public class FractionTest {
}
@Test
- public void testDoubleConstructorGoldenRatioThrows() {
+ void testDoubleConstructorGoldenRatioThrows() {
// the golden ratio is notoriously a difficult number for continuous fraction
Assertions.assertThrows(ArithmeticException.class,
() -> Fraction.from((1 + Math.sqrt(5)) / 2, 1.0e-12, 25)
@@ -146,7 +146,7 @@ public class FractionTest {
// MATH-1029
@Test
- public void testDoubleConstructorWithMaxDenominatorOverFlow() {
+ void testDoubleConstructorWithMaxDenominatorOverFlow() {
Assertions.assertThrows(ArithmeticException.class,
() -> Fraction.from(1e10, 1000)
);
@@ -156,7 +156,7 @@ public class FractionTest {
}
@Test
- public void testDoubleConstructorOverflow() {
+ void testDoubleConstructorOverflow() {
assertDoubleConstructorOverflow(0.75000000001455192);
assertDoubleConstructorOverflow(1.0e10);
assertDoubleConstructorOverflow(-1.0e10);
@@ -170,7 +170,7 @@ public class FractionTest {
}
@Test
- public void testDoubleConstructorWithEpsilonLimit() throws Exception {
+ void testDoubleConstructorWithEpsilonLimit() throws Exception {
assertFraction(2, 5, Fraction.from(0.4, 1.0e-5, 100));
assertFraction(3, 5, Fraction.from(0.6152, 0.02, 100));
@@ -182,7 +182,7 @@ public class FractionTest {
}
@Test
- public void testCompareTo() {
+ void testCompareTo() {
final Fraction a = Fraction.of(1, 2);
final Fraction b = Fraction.of(1, 3);
final Fraction c = Fraction.of(1, 2);
@@ -224,7 +224,7 @@ public class FractionTest {
}
@Test
- public void testDoubleValue() {
+ void testDoubleValue() {
assertDoubleValue(0.5, 1, 2);
assertDoubleValue(-0.5, -1, 2);
assertDoubleValue(-0.5, 1, -2);
@@ -237,7 +237,7 @@ public class FractionTest {
}
@Test
- public void testFloatValue() {
+ void testFloatValue() {
Assertions.assertEquals(0.5f, Fraction.of(1, 2).floatValue());
Assertions.assertEquals(0.5f, Fraction.of(-1, -2).floatValue());
Assertions.assertEquals(-0.5f, Fraction.of(-1, 2).floatValue());
@@ -254,7 +254,7 @@ public class FractionTest {
}
@Test
- public void testIntValue() {
+ void testIntValue() {
Assertions.assertEquals(0, Fraction.of(1, 2).intValue());
Assertions.assertEquals(0, Fraction.of(-1, -2).intValue());
Assertions.assertEquals(0, Fraction.of(-1, 2).intValue());
@@ -275,7 +275,7 @@ public class FractionTest {
}
@Test
- public void testLongValue() {
+ void testLongValue() {
Assertions.assertEquals(0L, Fraction.of(1, 2).longValue());
Assertions.assertEquals(0L, Fraction.of(-1, -2).longValue());
Assertions.assertEquals(0L, Fraction.of(-1, 2).longValue());
@@ -296,7 +296,7 @@ public class FractionTest {
}
@Test
- public void testAbs() {
+ void testAbs() {
for (final CommonTestCases.UnaryOperatorTestCase testCase : CommonTestCases.absTestCases()) {
final Fraction f = Fraction.of(testCase.operandNumerator, testCase.operandDenominator);
assertFraction(testCase.expectedNumerator, testCase.expectedDenominator, f.abs());
@@ -304,7 +304,7 @@ public class FractionTest {
}
@Test
- public void testReciprocal() {
+ void testReciprocal() {
for (final CommonTestCases.UnaryOperatorTestCase testCase : CommonTestCases.reciprocalTestCases()) {
final Fraction f = Fraction.of(testCase.operandNumerator, testCase.operandDenominator);
assertFraction(testCase.expectedNumerator, testCase.expectedDenominator, f.reciprocal());
@@ -315,7 +315,7 @@ public class FractionTest {
}
@Test
- public void testNegate() {
+ void testNegate() {
for (final CommonTestCases.UnaryOperatorTestCase testCase : CommonTestCases.negateTestCases()) {
final Fraction f = Fraction.of(testCase.operandNumerator, testCase.operandDenominator);
assertFraction(testCase.expectedNumerator, testCase.expectedDenominator, f.negate());
@@ -330,7 +330,7 @@ public class FractionTest {
}
@Test
- public void testAdd() {
+ void testAdd() {
for (final CommonTestCases.BinaryOperatorTestCase testCase : CommonTestCases.addFractionTestCases()) {
final Fraction f1 = Fraction.of(testCase.firstOperandNumerator, testCase.firstOperandDenominator);
final Fraction f2 = Fraction.of(testCase.secondOperandNumerator, testCase.secondOperandDenominator);
@@ -361,7 +361,7 @@ public class FractionTest {
}
@Test
- public void testDivide() {
+ void testDivide() {
for (final CommonTestCases.BinaryOperatorTestCase testCase : CommonTestCases.divideByFractionTestCases()) {
final Fraction f1 = Fraction.of(testCase.firstOperandNumerator, testCase.firstOperandDenominator);
final Fraction f2 = Fraction.of(testCase.secondOperandNumerator, testCase.secondOperandDenominator);
@@ -390,7 +390,7 @@ public class FractionTest {
}
@Test
- public void testMultiply() {
+ void testMultiply() {
for (final CommonTestCases.BinaryOperatorTestCase testCase : CommonTestCases.multiplyByFractionTestCases()) {
final Fraction f1 = Fraction.of(testCase.firstOperandNumerator, testCase.firstOperandDenominator);
final Fraction f2 = Fraction.of(testCase.secondOperandNumerator, testCase.secondOperandDenominator);
@@ -416,7 +416,7 @@ public class FractionTest {
}
@Test
- public void testPow() {
+ void testPow() {
for (final CommonTestCases.BinaryIntOperatorTestCase testCase : CommonTestCases.powTestCases()) {
final Fraction f1 = Fraction.of(testCase.firstOperandNumerator, testCase.firstOperandDenominator);
final int exponent = testCase.secondOperand;
@@ -430,7 +430,7 @@ public class FractionTest {
}
@Test
- public void testSubtract() {
+ void testSubtract() {
for (final CommonTestCases.BinaryOperatorTestCase testCase : CommonTestCases.subtractFractionTestCases()) {
final Fraction f1 = Fraction.of(testCase.firstOperandNumerator, testCase.firstOperandDenominator);
final Fraction f2 = Fraction.of(testCase.secondOperandNumerator, testCase.secondOperandDenominator);
@@ -461,7 +461,7 @@ public class FractionTest {
}
@Test
- public void testEqualsAndHashCode() {
+ void testEqualsAndHashCode() {
final Fraction zero = Fraction.of(0, 1);
Assertions.assertEquals(zero, zero);
Assertions.assertNotEquals(zero, null);
@@ -534,17 +534,17 @@ public class FractionTest {
}
@Test
- public void testAdditiveNeutral() {
+ void testAdditiveNeutral() {
Assertions.assertEquals(Fraction.ZERO, Fraction.ONE.zero());
}
@Test
- public void testMultiplicativeNeutral() {
+ void testMultiplicativeNeutral() {
Assertions.assertEquals(Fraction.ONE, Fraction.ZERO.one());
}
@Test
- public void testSerial() {
+ void testSerial() {
final Fraction[] fractions = {
Fraction.of(3, 4), Fraction.ONE, Fraction.ZERO,
Fraction.of(17), Fraction.from(Math.PI, 1000),
@@ -557,7 +557,7 @@ public class FractionTest {
}
@Test
- public void testToString() {
+ void testToString() {
Assertions.assertEquals("0", Fraction.of(0, 3).toString());
Assertions.assertEquals("0", Fraction.of(0, -3).toString());
Assertions.assertEquals("3", Fraction.of(6, 2).toString());
@@ -567,7 +567,7 @@ public class FractionTest {
}
@Test
- public void testParse() {
+ void testParse() {
final String[] validExpressions = new String[] {
"1 / 2",
"-1 / 2",
@@ -614,7 +614,7 @@ public class FractionTest {
}
@Test
- public void testMath1261() {
+ void testMath1261() {
final Fraction a = Fraction.of(Integer.MAX_VALUE, 2);
assertFraction(Integer.MAX_VALUE, 1, a.multiply(2));
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/DigammaTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/DigammaTest.java
index 02d285f..b8431a6 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/DigammaTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/DigammaTest.java
@@ -24,7 +24,7 @@ import org.junit.jupiter.api.Test;
*/
public class DigammaTest {
@Test
- public void testDigammaLargeArgs() {
+ void testDigammaLargeArgs() {
double eps = 1e-8;
Assertions.assertEquals(4.6001618527380874002, Digamma.value(100), eps);
Assertions.assertEquals(3.9019896734278921970, Digamma.value(50), eps);
@@ -41,7 +41,7 @@ public class DigammaTest {
}
@Test
- public void testDigammaSmallArgs() {
+ void testDigammaSmallArgs() {
// values for negative powers of 10 from 1 to 30 as computed by webMathematica with 20 digits.
// For example, to compute trigamma($i) = Polygamma(1, $i), use
//
@@ -58,7 +58,7 @@ public class DigammaTest {
}
@Test
- public void testDigammaZero() {
+ void testDigammaZero() {
// webMathematica states Complexinfinity.
// The value computed is Double.NEGATIVE_INFINITY but we leave this as a test for infinity
// since the next value down -Double.MIN_VALUE is Double.POSITIVE_INFINITY indicating
@@ -67,7 +67,7 @@ public class DigammaTest {
}
@Test
- public void testDigammaNonRealArgs() {
+ void testDigammaNonRealArgs() {
Assertions.assertTrue(Double.isNaN(Digamma.value(Double.NaN)));
Assertions.assertTrue(Double.isInfinite(Digamma.value(Double.POSITIVE_INFINITY)));
Assertions.assertTrue(Double.isInfinite(Digamma.value(Double.NEGATIVE_INFINITY)));
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfDifferenceTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfDifferenceTest.java
index da9bf8a..881563c 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfDifferenceTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfDifferenceTest.java
@@ -28,7 +28,7 @@ public class ErfDifferenceTest {
* with results obtained from Erf.value(double) and Erfc.value(double).
*/
@Test
- public void testTwoArgumentErf() {
+ void testTwoArgumentErf() {
final double[] xi = new double[] {-2, -1, -0.9, -0.1, 0, 0.1, 0.9, 1, 2};
for (double x1 : xi) {
for (double x2 : xi) {
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfTest.java
index c1a021d..f9b3f62 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfTest.java
@@ -24,7 +24,7 @@ import org.junit.jupiter.api.Test;
*/
public class ErfTest {
@Test
- public void testErf0() {
+ void testErf0() {
double actual = Erf.value(0);
double expected = 0;
Assertions.assertEquals(expected, actual, 1e-15);
@@ -32,7 +32,7 @@ public class ErfTest {
}
@Test
- public void testErf1960() {
+ void testErf1960() {
double x = 1.960 / Math.sqrt(2);
double actual = Erf.value(x);
double expected = 0.95;
@@ -46,7 +46,7 @@ public class ErfTest {
}
@Test
- public void testErf2576() {
+ void testErf2576() {
double x = 2.576 / Math.sqrt(2);
double actual = Erf.value(x);
double expected = 0.99;
@@ -60,7 +60,7 @@ public class ErfTest {
}
@Test
- public void testErf2807() {
+ void testErf2807() {
double x = 2.807 / Math.sqrt(2);
double actual = Erf.value(x);
double expected = 0.995;
@@ -74,7 +74,7 @@ public class ErfTest {
}
@Test
- public void testErf3291() {
+ void testErf3291() {
double x = 3.291 / Math.sqrt(2);
double actual = Erf.value(x);
double expected = 0.999;
@@ -91,7 +91,7 @@ public class ErfTest {
* MATH-301, MATH-456
*/
@Test
- public void testLargeValues() {
+ void testLargeValues() {
for (int i = 1; i < 200; i *= 10) {
double result = Erf.value(i);
Assertions.assertFalse(Double.isNaN(result));
@@ -117,7 +117,7 @@ public class ErfTest {
* (Apple OSX packaged version) erfl (extended precision erf).
*/
@Test
- public void testErfGnu() {
+ void testErfGnu() {
final double tol = 1E-15;
final double[] gnuValues = new double[] {
-1, -1, -1, -1, -1,
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfcTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfcTest.java
index 1257152..99f2845 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfcTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfcTest.java
@@ -28,7 +28,7 @@ public class ErfcTest {
* (Apple OSX packaged version) erfcl (extended precision erfc).
*/
@Test
- public void testErfcGnu() {
+ void testErfcGnu() {
final double tol = 1e-15;
final double[] gnuValues = new double[] {
2, 2, 2, 2, 2,
@@ -56,7 +56,7 @@ public class ErfcTest {
* http//www.jstatsoft.org/v11/a05/paper
*/
@Test
- public void testErfcMaple() {
+ void testErfcMaple() {
double[][] ref = new double[][] {
{0.1, 4.60172162722971e-01},
{1.2, 1.15069670221708e-01},
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/GammaTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/GammaTest.java
index f14606b..1c19785 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/GammaTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/GammaTest.java
@@ -507,7 +507,7 @@ public class GammaTest {
};
@Test
- public void testGamma() {
+ void testGamma() {
for (int i = 0; i < GAMMA_REF.length; i++) {
final double[] ref = GAMMA_REF[i];
final double x = ref[0];
@@ -532,14 +532,14 @@ public class GammaTest {
}
@Test
- public void testGammaNegativeInteger() {
+ void testGammaNegativeInteger() {
for (int i = -100; i <= 0; i++) {
Assertions.assertTrue(Double.isNaN(Gamma.value(i)), Integer.toString(i));
}
}
@Test
- public void testGammaNegativeDouble() {
+ void testGammaNegativeDouble() {
// check that the gamma function properly switches sign
// see: https://en.wikipedia.org/wiki/Gamma_function
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InvGamma1pm1Test.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InvGamma1pm1Test.java
index d99b316..07f8087 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InvGamma1pm1Test.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InvGamma1pm1Test.java
@@ -65,7 +65,7 @@ public class InvGamma1pm1Test {
};
@Test
- public void testInvGamma1pm1() {
+ void testInvGamma1pm1() {
final int ulps = 3;
for (int i = 0; i < INV_GAMMA1P_M1_REF.length; i++) {
final double[] ref = INV_GAMMA1P_M1_REF[i];
@@ -78,14 +78,14 @@ public class InvGamma1pm1Test {
}
@Test
- public void testInvGamma1pm1Precondition1() {
+ void testInvGamma1pm1Precondition1() {
Assertions.assertThrows(GammaException.class,
() -> InvGamma1pm1.value(-0.51)
);
}
@Test
- public void testInvGamma1pm1Precondition2() {
+ void testInvGamma1pm1Precondition2() {
Assertions.assertThrows(GammaException.class,
() -> InvGamma1pm1.value(1.51)
);
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InverseErfTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InverseErfTest.java
index af2295d..f19837e 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InverseErfTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InverseErfTest.java
@@ -24,14 +24,14 @@ import org.junit.jupiter.api.Test;
*/
public class InverseErfTest {
@Test
- public void testErfInvNaN() {
+ void testErfInvNaN() {
Assertions.assertTrue(Double.isNaN(InverseErf.value(-1.001)));
Assertions.assertTrue(Double.isNaN(InverseErf.value(+1.001)));
Assertions.assertTrue(Double.isNaN(InverseErf.value(Double.NaN)));
}
@Test
- public void testErfInvInfinite() {
+ void testErfInvInfinite() {
Assertions.assertTrue(Double.isInfinite(InverseErf.value(-1)));
Assertions.assertTrue(InverseErf.value(-1) < 0);
Assertions.assertTrue(Double.isInfinite(InverseErf.value(+1)));
@@ -39,7 +39,7 @@ public class InverseErfTest {
}
@Test
- public void testErfInv() {
+ void testErfInv() {
for (double x = -5.9; x < 5.9; x += 0.01) {
final double y = Erf.value(x);
final double dydx = 2 * Math.exp(-x * x) / Math.sqrt(Math.PI);
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InverseErfcTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InverseErfcTest.java
index a902927..dd9d015 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InverseErfcTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InverseErfcTest.java
@@ -24,13 +24,13 @@ import org.junit.jupiter.api.Test;
*/
public class InverseErfcTest {
@Test
- public void testErfcInvNaN() {
+ void testErfcInvNaN() {
Assertions.assertTrue(Double.isNaN(InverseErfc.value(-0.001)));
Assertions.assertTrue(Double.isNaN(InverseErfc.value(+2.001)));
}
@Test
- public void testErfcInvInfinite() {
+ void testErfcInvInfinite() {
Assertions.assertTrue(Double.isInfinite(InverseErfc.value(-0)));
Assertions.assertTrue(InverseErfc.value(0) > 0);
Assertions.assertTrue(Double.isInfinite(InverseErfc.value(+2)));
@@ -38,7 +38,7 @@ public class InverseErfcTest {
}
@Test
- public void testErfcInv() {
+ void testErfcInv() {
for (double x = -5.85; x < 5.9; x += 0.01) {
final double y = Erfc.value(x);
final double dydxAbs = 2 * Math.exp(-x * x) / Math.sqrt(Math.PI);
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LanczosApproximationTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LanczosApproximationTest.java
index b9680fe..d562909 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LanczosApproximationTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LanczosApproximationTest.java
@@ -24,12 +24,12 @@ import org.junit.jupiter.api.Test;
*/
public class LanczosApproximationTest {
@Test
- public void testG() {
+ void testG() {
Assertions.assertEquals(607d / 128d, LanczosApproximation.g(), 0d);
}
@Test
- public void testSomeValues() {
+ void testSomeValues() {
// Given that few values are checked, this test would only serve
// as early warning of unexpected changes to the current code.
Assertions.assertEquals(29.020294557631818d, LanczosApproximation.value(0.1d), 0d);
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogBetaTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogBetaTest.java
index aebaeab..9e6a68b 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogBetaTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogBetaTest.java
@@ -534,7 +534,7 @@ public class LogBetaTest {
};
@Test
- public void testLogBeta() {
+ void testLogBeta() {
final int ulps = 3;
for (int i = 0; i < LOG_BETA_REF.length; i++) {
final double[] ref = LOG_BETA_REF[i];
@@ -550,37 +550,37 @@ public class LogBetaTest {
}
@Test
- public void testLogBetaNanPositive() {
+ void testLogBetaNanPositive() {
testLogBeta(Double.NaN, Double.NaN, 2);
}
@Test
- public void testLogBetaPositiveNan() {
+ void testLogBetaPositiveNan() {
testLogBeta(Double.NaN, 1, Double.NaN);
}
@Test
- public void testLogBetaNegativePositive() {
+ void testLogBetaNegativePositive() {
testLogBeta(Double.NaN, -1, 2);
}
@Test
- public void testLogBetaPositiveNegative() {
+ void testLogBetaPositiveNegative() {
testLogBeta(Double.NaN, 1, -2);
}
@Test
- public void testLogBetaZeroPositive() {
+ void testLogBetaZeroPositive() {
testLogBeta(Double.NaN, 0, 2);
}
@Test
- public void testLogBetaPositiveZero() {
+ void testLogBetaPositiveZero() {
testLogBeta(Double.NaN, 1, 0);
}
@Test
- public void testLogBetaPositivePositive() {
+ void testLogBetaPositivePositive() {
testLogBeta(-0.693147180559945, 1, 2);
}
@@ -616,7 +616,7 @@ public class LogBetaTest {
}
@Test
- public void testLogGammaMinusLogGammaSum() {
+ void testLogGammaMinusLogGammaSum() {
final int ulps = 4;
for (int i = 0; i < LOG_GAMMA_MINUS_LOG_GAMMA_SUM_REF.length; i++) {
final double[] ref = LOG_GAMMA_MINUS_LOG_GAMMA_SUM_REF[i];
@@ -632,14 +632,14 @@ public class LogBetaTest {
}
@Test
- public void testLogGammaMinusLogGammaSumPrecondition1() {
+ void testLogGammaMinusLogGammaSumPrecondition1() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> logGammaMinusLogGammaSum(-1, 8)
);
}
@Test
- public void testLogGammaMinusLogGammaSumPrecondition2() {
+ void testLogGammaMinusLogGammaSumPrecondition2() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> logGammaMinusLogGammaSum(1, 7)
);
@@ -671,7 +671,7 @@ public class LogBetaTest {
}
@Test
- public void testSumDeltaMinusDeltaSum() {
+ void testSumDeltaMinusDeltaSum() {
final int ulps = 3;
for (int i = 0; i < SUM_DELTA_MINUS_DELTA_SUM_REF.length; i++) {
final double[] ref = SUM_DELTA_MINUS_DELTA_SUM_REF[i];
@@ -687,14 +687,14 @@ public class LogBetaTest {
}
@Test
- public void testSumDeltaMinusDeltaSumPrecondition1() {
+ void testSumDeltaMinusDeltaSumPrecondition1() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> sumDeltaMinusDeltaSum(9, 10)
);
}
@Test
- public void testSumDeltaMinusDeltaSumPrecondition2() {
+ void testSumDeltaMinusDeltaSumPrecondition2() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> sumDeltaMinusDeltaSum(10, 9)
);
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGamma1pTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGamma1pTest.java
index 33ac6ad..c1ea8f6 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGamma1pTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGamma1pTest.java
@@ -44,7 +44,7 @@ public class LogGamma1pTest {
};
@Test
- public void testLogGamma1p() {
+ void testLogGamma1p() {
final int ulps = 3;
for (int i = 0; i < LOG_GAMMA1P_REF.length; i++) {
final double[] ref = LOG_GAMMA1P_REF[i];
@@ -57,14 +57,14 @@ public class LogGamma1pTest {
}
@Test
- public void testLogGamma1pPrecondition1() {
+ void testLogGamma1pPrecondition1() {
Assertions.assertThrows(GammaException.class,
() -> LogGamma1p.value(-0.51)
);
}
@Test
- public void testLogGamma1pPrecondition2() {
+ void testLogGamma1pPrecondition2() {
Assertions.assertThrows(GammaException.class,
() -> LogGamma1p.value(1.51)
);
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGammaSumTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGammaSumTest.java
index 9bba2b0..a54b6cc 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGammaSumTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGammaSumTest.java
@@ -129,7 +129,7 @@ public class LogGammaSumTest {
};
@Test
- public void testLogGammaSum() {
+ void testLogGammaSum() {
final int ulps = 2;
for (int i = 0; i < LOG_GAMMA_SUM_REF.length; i++) {
final double[] ref = LOG_GAMMA_SUM_REF[i];
@@ -145,28 +145,28 @@ public class LogGammaSumTest {
}
@Test
- public void testLogGammaSumPrecondition1() {
+ void testLogGammaSumPrecondition1() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> LogGammaSum.value(0, 1)
);
}
@Test
- public void testLogGammaSumPrecondition2() {
+ void testLogGammaSumPrecondition2() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> LogGammaSum.value(3, 1)
);
}
@Test
- public void testLogGammaSumPrecondition3() {
+ void testLogGammaSumPrecondition3() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> LogGammaSum.value(1, 0)
);
}
@Test
- public void testLogGammaSumPrecondition4() {
+ void testLogGammaSumPrecondition4() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> LogGammaSum.value(1, 3)
);
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGammaTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGammaTest.java
index 698d8e8..4cbc033 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGammaTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGammaTest.java
@@ -176,27 +176,27 @@ public class LogGammaTest {
};
@Test
- public void testLogGammaNan() {
+ void testLogGammaNan() {
testLogGamma(Double.NaN, Double.NaN);
}
@Test
- public void testLogGammaNegative() {
+ void testLogGammaNegative() {
testLogGamma(Double.NaN, -1.0);
}
@Test
- public void testLogGammaZero() {
+ void testLogGammaZero() {
testLogGamma(Double.NaN, 0.0);
}
@Test
- public void testLogGammaPositive() {
+ void testLogGammaPositive() {
testLogGamma(0.6931471805599457, 3.0);
}
@Test
- public void testLogGamma() {
+ void testLogGamma() {
final int ulps = 3;
for (int i = 0; i < LOG_GAMMA_REF.length; i++) {
final double[] data = LOG_GAMMA_REF[i];
@@ -214,12 +214,12 @@ public class LogGammaTest {
}
@Test
- public void testLogGammaPrecondition1() {
+ void testLogGammaPrecondition1() {
Assertions.assertTrue(Double.isNaN(LogGamma.value(0.0)));
}
@Test
- public void testLogGammaPrecondition2() {
+ void testLogGammaPrecondition2() {
Assertions.assertTrue(Double.isNaN(LogGamma.value(-1.0)));
}
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/RegularizedBetaTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/RegularizedBetaTest.java
index 7fdeaed..32f0e03 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/RegularizedBetaTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/RegularizedBetaTest.java
@@ -24,70 +24,70 @@ import org.junit.jupiter.api.Test;
*/
public class RegularizedBetaTest {
@Test
- public void testRegularizedBetaNanPositivePositive() {
+ void testRegularizedBetaNanPositivePositive() {
testRegularizedBeta(Double.NaN, Double.NaN, 1.0, 1.0);
}
@Test
- public void testRegularizedBetaPositiveNanPositive() {
+ void testRegularizedBetaPositiveNanPositive() {
testRegularizedBeta(Double.NaN, 0.5, Double.NaN, 1.0);
}
@Test
- public void testRegularizedBetaPositivePositiveNan() {
+ void testRegularizedBetaPositivePositiveNan() {
testRegularizedBeta(Double.NaN, 0.5, 1.0, Double.NaN);
}
@Test
- public void testRegularizedBetaNegativePositivePositive() {
+ void testRegularizedBetaNegativePositivePositive() {
testRegularizedBeta(Double.NaN, -0.5, 1.0, 2.0);
}
@Test
- public void testRegularizedBetaPositiveNegativePositive() {
+ void testRegularizedBetaPositiveNegativePositive() {
testRegularizedBeta(Double.NaN, 0.5, -1.0, 2.0);
}
@Test
- public void testRegularizedBetaPositivePositiveNegative() {
+ void testRegularizedBetaPositivePositiveNegative() {
testRegularizedBeta(Double.NaN, 0.5, 1.0, -2.0);
}
@Test
- public void testRegularizedBetaZeroPositivePositive() {
+ void testRegularizedBetaZeroPositivePositive() {
testRegularizedBeta(0.0, 0.0, 1.0, 2.0);
}
@Test
- public void testRegularizedBetaPositiveZeroPositive() {
+ void testRegularizedBetaPositiveZeroPositive() {
testRegularizedBeta(Double.NaN, 0.5, 0.0, 2.0);
}
@Test
- public void testRegularizedBetaPositivePositiveZero() {
+ void testRegularizedBetaPositivePositiveZero() {
testRegularizedBeta(Double.NaN, 0.5, 1.0, 0.0);
}
@Test
- public void testRegularizedBetaAboveOnePositivePositive() {
+ void testRegularizedBetaAboveOnePositivePositive() {
testRegularizedBeta(Double.NaN, 1.5, 1.0, 2.0);
}
@Test
- public void testRegularizedBetaPositivePositivePositive() {
+ void testRegularizedBetaPositivePositivePositive() {
testRegularizedBeta(0.75, 0.5, 1.0, 2.0);
}
@Test
- public void testRegularizedBetaTinyArgument() {
+ void testRegularizedBetaTinyArgument() {
double actual = RegularizedBeta.value(1e-17, 1.0, 1e12);
// This value is from R: pbeta(1e-17,1,1e12)
Assertions.assertEquals(9.999950000166648e-6, actual, 1e-16);
}
@Test
- public void testMath1067() {
+ void testMath1067() {
final double x = 0.22580645161290325;
final double a = 64.33333333333334;
final double b = 223;
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/RegularizedGammaTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/RegularizedGammaTest.java
index ca8e895..5557e50 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/RegularizedGammaTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/RegularizedGammaTest.java
@@ -24,42 +24,42 @@ import org.junit.jupiter.api.Test;
*/
public class RegularizedGammaTest {
@Test
- public void testRegularizedGammaNanPositive() {
+ void testRegularizedGammaNanPositive() {
testRegularizedGamma(Double.NaN, Double.NaN, 1.0);
}
@Test
- public void testRegularizedGammaPositiveNan() {
+ void testRegularizedGammaPositiveNan() {
testRegularizedGamma(Double.NaN, 1.0, Double.NaN);
}
@Test
- public void testRegularizedGammaNegativePositive() {
+ void testRegularizedGammaNegativePositive() {
testRegularizedGamma(Double.NaN, -1.5, 1.0);
}
@Test
- public void testRegularizedGammaPositiveNegative() {
+ void testRegularizedGammaPositiveNegative() {
testRegularizedGamma(Double.NaN, 1.0, -1.0);
}
@Test
- public void testRegularizedGammaZeroPositive() {
+ void testRegularizedGammaZeroPositive() {
testRegularizedGamma(Double.NaN, 0.0, 1.0);
}
@Test
- public void testRegularizedGammaPositiveZero() {
+ void testRegularizedGammaPositiveZero() {
testRegularizedGamma(0.0, 1.0, 0.0);
}
@Test
- public void testRegularizedGammaPositivePositive() {
+ void testRegularizedGammaPositivePositive() {
testRegularizedGamma(0.632120558828558, 1.0, 1.0);
}
@Test
- public void testRegularizedGammaPWithACloseToZero() {
+ void testRegularizedGammaPWithACloseToZero() {
// Creates a case where the regularized gamma P series is evaluated and the
// result is outside the expected bounds of [0, 1]. This should be clipped to 1.0.
final double a = 1e-18;
@@ -69,7 +69,7 @@ public class RegularizedGammaTest {
}
@Test
- public void testRegularizedGammaPWithAVeryCloseToZero() {
+ void testRegularizedGammaPWithAVeryCloseToZero() {
// Creates a case where the partial sum is infinite due to inclusion of 1 / a
final double a = Double.MIN_VALUE;
// x must force use of the series in regularized gamma P using x < a + 1
@@ -85,7 +85,7 @@ public class RegularizedGammaTest {
}
@Test
- public void testRegularizedGammaMaxIterationsExceededThrows() {
+ void testRegularizedGammaMaxIterationsExceededThrows() {
final double a = 1.0;
final double x = 1.0;
// OK without
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/TrigammaTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/TrigammaTest.java
index 1a8012f..a865c92 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/TrigammaTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/TrigammaTest.java
@@ -24,7 +24,7 @@ import org.junit.jupiter.api.Test;
*/
public class TrigammaTest {
@Test
- public void testTrigamma() {
+ void testTrigamma() {
double eps = 1e-8;
// computed using webMathematica. For example, to compute trigamma($i) = Polygamma(1, $i), use
//
@@ -62,7 +62,7 @@ public class TrigammaTest {
}
@Test
- public void testTrigammaNonRealArgs() {
+ void testTrigammaNonRealArgs() {
Assertions.assertTrue(Double.isNaN(Trigamma.value(Double.NaN)));
Assertions.assertTrue(Double.isInfinite(Trigamma.value(Double.POSITIVE_INFINITY)));
Assertions.assertTrue(Double.isInfinite(Trigamma.value(Double.NEGATIVE_INFINITY)));
diff --git a/commons-numbers-primes/src/test/java/org/apache/commons/numbers/primes/PrimesTest.java b/commons-numbers-primes/src/test/java/org/apache/commons/numbers/primes/PrimesTest.java
index 9667a16..e7242c8 100644
--- a/commons-numbers-primes/src/test/java/org/apache/commons/numbers/primes/PrimesTest.java
+++ b/commons-numbers-primes/src/test/java/org/apache/commons/numbers/primes/PrimesTest.java
@@ -85,7 +85,7 @@ public class PrimesTest {
}
@Test
- public void testNextPrime() {
+ void testNextPrime() {
Assertions.assertEquals(2, Primes.nextPrime(0));
Assertions.assertEquals(2, Primes.nextPrime(1));
@@ -115,7 +115,7 @@ public class PrimesTest {
}
@Test
- public void testIsPrime() throws Exception {
+ void testIsPrime() throws Exception {
for (int i : BELOW_2) {
Assertions.assertFalse(Primes.isPrime(i));
}
@@ -152,7 +152,7 @@ public class PrimesTest {
}
@Test
- public void testPrimeFactors() throws Exception {
+ void testPrimeFactors() throws Exception {
for (int i : BELOW_2) {
assertPrimeFactorsException(i, MessageFormat.format(Primes.NUMBER_TOO_SMALL, i, 2));
}
diff --git a/commons-numbers-primes/src/test/java/org/apache/commons/numbers/primes/SmallPrimesTest.java b/commons-numbers-primes/src/test/java/org/apache/commons/numbers/primes/SmallPrimesTest.java
index 4305109..4f3dd5f 100644
--- a/commons-numbers-primes/src/test/java/org/apache/commons/numbers/primes/SmallPrimesTest.java
+++ b/commons-numbers-primes/src/test/java/org/apache/commons/numbers/primes/SmallPrimesTest.java
@@ -30,7 +30,7 @@ public class SmallPrimesTest {
private static final int[] LARGE_PRIME = {3673, 3677};
@Test
- public void smallTrialDivision_smallComposite() {
+ void smallTrialDivision_smallComposite() {
final List<Integer> factors = new ArrayList<Integer>();
final int result = SmallPrimes.smallTrialDivision(3 * 7 * 23, factors);
Assertions.assertEquals(1, result);
@@ -38,7 +38,7 @@ public class SmallPrimesTest {
}
@Test
- public void smallTrialDivision_repeatedFactors() {
+ void smallTrialDivision_repeatedFactors() {
final List<Integer> factors = new ArrayList<Integer>();
final int result = SmallPrimes.smallTrialDivision(2 * 2 * 3 * 3 * 3, factors);
Assertions.assertEquals(1, result);
@@ -46,7 +46,7 @@ public class SmallPrimesTest {
}
@Test
- public void smallTrialDivision_oneFactor() {
+ void smallTrialDivision_oneFactor() {
final List<Integer> factors = new ArrayList<Integer>();
final int result = SmallPrimes.smallTrialDivision(59, factors);
Assertions.assertEquals(1, result);
@@ -54,7 +54,7 @@ public class SmallPrimesTest {
}
@Test
- public void smallTrialDivision_BoundaryPrimes() {
+ void smallTrialDivision_BoundaryPrimes() {
final List<Integer> factors = new ArrayList<Integer>();
final int penultimatePrime = SmallPrimes.PRIMES[SmallPrimes.PRIMES.length - 2];
final int result = SmallPrimes.smallTrialDivision(penultimatePrime * SmallPrimes.PRIMES_LAST, factors);
@@ -63,7 +63,7 @@ public class SmallPrimesTest {
}
@Test
- public void smallTrialDivision_largeComposite() {
+ void smallTrialDivision_largeComposite() {
final List<Integer> factors = new ArrayList<Integer>();
final int result = SmallPrimes.smallTrialDivision(2 * 5 * LARGE_PRIME[0], factors);
Assertions.assertEquals(LARGE_PRIME[0], result);
@@ -71,7 +71,7 @@ public class SmallPrimesTest {
}
@Test
- public void smallTrialDivision_noSmallPrimeFactors() {
+ void smallTrialDivision_noSmallPrimeFactors() {
final List<Integer> factors = new ArrayList<Integer>();
final int result = SmallPrimes.smallTrialDivision(LARGE_PRIME[0] * LARGE_PRIME[1], factors);
Assertions.assertEquals(LARGE_PRIME[0] * LARGE_PRIME[1], result);
@@ -79,7 +79,7 @@ public class SmallPrimesTest {
}
@Test
- public void boundedTrialDivision_twoDifferentFactors() {
+ void boundedTrialDivision_twoDifferentFactors() {
final List<Integer> factors = new ArrayList<Integer>();
final int result = SmallPrimes.boundedTrialDivision(LARGE_PRIME[0] * LARGE_PRIME[1], Integer.MAX_VALUE,
factors);
@@ -88,7 +88,7 @@ public class SmallPrimesTest {
}
@Test
- public void boundedTrialDivision_square() {
+ void boundedTrialDivision_square() {
final List<Integer> factors = new ArrayList<Integer>();
final int result = SmallPrimes.boundedTrialDivision(LARGE_PRIME[0] * LARGE_PRIME[0], Integer.MAX_VALUE,
factors);
@@ -97,37 +97,37 @@ public class SmallPrimesTest {
}
@Test
- public void trialDivision_smallComposite() {
+ void trialDivision_smallComposite() {
final List<Integer> factors = SmallPrimes.trialDivision(5 * 11 * 29 * 103);
Assertions.assertEquals(Arrays.asList(5, 11, 29, 103), factors);
}
@Test
- public void trialDivision_repeatedFactors() {
+ void trialDivision_repeatedFactors() {
final List<Integer> factors = SmallPrimes.trialDivision(2 * 2 * 2 * 2 * 5 * 5);
Assertions.assertEquals(Arrays.asList(2, 2, 2, 2, 5, 5), factors);
}
@Test
- public void trialDivision_oneSmallFactor() {
+ void trialDivision_oneSmallFactor() {
final List<Integer> factors = SmallPrimes.trialDivision(101);
Assertions.assertEquals(Collections.singletonList(101), factors);
}
@Test
- public void trialDivision_largeComposite() {
+ void trialDivision_largeComposite() {
final List<Integer> factors = SmallPrimes.trialDivision(2 * 3 * LARGE_PRIME[0]);
Assertions.assertEquals(Arrays.asList(2, 3, LARGE_PRIME[0]), factors);
}
@Test
- public void trialDivision_veryLargeComposite() {
+ void trialDivision_veryLargeComposite() {
final List<Integer> factors = SmallPrimes.trialDivision(2 * LARGE_PRIME[0] * LARGE_PRIME[1]);
Assertions.assertEquals(Arrays.asList(2, LARGE_PRIME[0], LARGE_PRIME[1]), factors);
}
@Test
- public void millerRabinPrimeTest_primes() {
+ void millerRabinPrimeTest_primes() {
for (final int n : PrimesTest.PRIMES) {
if (n % 2 == 1) {
Assertions.assertTrue(SmallPrimes.millerRabinPrimeTest(n));
@@ -136,7 +136,7 @@ public class SmallPrimesTest {
}
@Test
- public void millerRabinPrimeTest_composites() {
+ void millerRabinPrimeTest_composites() {
for (final int n : PrimesTest.NOT_PRIMES) {
if (n % 2 == 1) {
Assertions.assertFalse(SmallPrimes.millerRabinPrimeTest(n));
diff --git a/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/QuaternionTest.java b/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/QuaternionTest.java
index aede102..4ea8545 100644
--- a/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/QuaternionTest.java
+++ b/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/QuaternionTest.java
@@ -28,12 +28,12 @@ public class QuaternionTest {
private static final double COMPARISON_EPS = 1e-14;
@Test
- public void testZeroQuaternion() {
+ void testZeroQuaternion() {
Assertions.assertEquals(0, Quaternion.ZERO.norm(), 0d);
}
@Test
- public void testUnitQuaternions() {
+ void testUnitQuaternions() {
Assertions.assertEquals(1, Quaternion.ONE.norm(), 0d);
Assertions.assertSame(Quaternion.ONE, Quaternion.ONE.normalize());
@@ -48,7 +48,7 @@ public class QuaternionTest {
}
@Test
- public final void testAccessors1() {
+ final void testAccessors1() {
final double q0 = 2;
final double q1 = 5.4;
final double q2 = 17;
@@ -62,7 +62,7 @@ public class QuaternionTest {
}
@Test
- public final void testAccessors2() {
+ final void testAccessors2() {
final double q0 = 2;
final double q1 = 5.4;
final double q2 = 17;
@@ -79,7 +79,7 @@ public class QuaternionTest {
}
@Test
- public final void testAccessors3() {
+ final void testAccessors3() {
final double q0 = 2;
final double q1 = 5.4;
final double q2 = 17;
@@ -96,14 +96,14 @@ public class QuaternionTest {
}
@Test
- public void testWrongDimension() {
+ void testWrongDimension() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> Quaternion.of(new double[] {1, 2})
);
}
@Test
- public final void testConjugate() {
+ final void testConjugate() {
final double q0 = 2;
final double q1 = 5.4;
final double q2 = 17;
@@ -120,7 +120,7 @@ public class QuaternionTest {
/* TODO remove dependency on Vector3D
@Test
- public final void testProductQuaternionQuaternion() {
+ final void testProductQuaternionQuaternion() {
// Case : analytic test case
@@ -165,7 +165,7 @@ public class QuaternionTest {
*/
/* TODO remove dependency on Vector3D
@Test
- public final void testProductQuaternionVector() {
+ final void testProductQuaternionVector() {
// Case : Product between a vector and a quaternion : QxV
@@ -216,7 +216,7 @@ public class QuaternionTest {
}
*/
@Test
- public final void testDotProductQuaternionQuaternion() {
+ final void testDotProductQuaternionQuaternion() {
// expected output
final double expected = -6.;
// inputs
@@ -231,7 +231,7 @@ public class QuaternionTest {
}
@Test
- public final void testScalarMultiplyDouble() {
+ final void testScalarMultiplyDouble() {
// expected outputs
final double w = 1.6;
final double x = -4.8;
@@ -250,7 +250,7 @@ public class QuaternionTest {
}
@Test
- public final void testAddQuaternionQuaternion() {
+ final void testAddQuaternionQuaternion() {
// expected outputs
final double w = 4;
final double x = -1;
@@ -275,7 +275,7 @@ public class QuaternionTest {
}
@Test
- public final void testSubtractQuaternionQuaternion() {
+ final void testSubtractQuaternionQuaternion() {
// expected outputs
final double w = -2.;
final double x = 5.;
@@ -300,7 +300,7 @@ public class QuaternionTest {
}
@Test
- public final void testNorm() {
+ final void testNorm() {
final double q0 = 2;
final double q1 = 1;
@@ -317,7 +317,7 @@ public class QuaternionTest {
}
@Test
- public final void testNormalize() {
+ final void testNormalize() {
final Quaternion q = Quaternion.of(2, 1, -4, -2);
@@ -334,7 +334,7 @@ public class QuaternionTest {
}
@Test
- public final void testNormalizeFail_zero() {
+ final void testNormalizeFail_zero() {
final Quaternion q = Quaternion.of(0, 0, 0, 0);
Assertions.assertThrows(IllegalStateException.class,
q::normalize
@@ -342,7 +342,7 @@ public class QuaternionTest {
}
@Test
- public final void testNormalizeFail_nan() {
+ final void testNormalizeFail_nan() {
final Quaternion q = Quaternion.of(0, 0, 0, Double.NaN);
Assertions.assertThrows(IllegalStateException.class,
q::normalize
@@ -351,7 +351,7 @@ public class QuaternionTest {
}
@Test
- public final void testNormalizeFail_positiveInfinity() {
+ final void testNormalizeFail_positiveInfinity() {
final Quaternion q = Quaternion.of(0, 0, Double.POSITIVE_INFINITY, 0);
Assertions.assertThrows(IllegalStateException.class,
q::normalize
@@ -359,7 +359,7 @@ public class QuaternionTest {
}
@Test
- public final void testNormalizeFail_negativeInfinity() {
+ final void testNormalizeFail_negativeInfinity() {
final Quaternion q = Quaternion.of(0, Double.NEGATIVE_INFINITY, 0, 0);
Assertions.assertThrows(IllegalStateException.class,
q::normalize
@@ -367,7 +367,7 @@ public class QuaternionTest {
}
@Test
- public final void testObjectEquals() {
+ final void testObjectEquals() {
final double one = 1;
final Quaternion q1 = Quaternion.of(one, one, one, one);
Assertions.assertEquals(q1, q1);
@@ -382,7 +382,7 @@ public class QuaternionTest {
}
@Test
- public void testHashCode() {
+ void testHashCode() {
Quaternion x = Quaternion.of(0.0, 0.0, 0.0, 0.0);
Quaternion y = Quaternion.of(0.0, 0.0 + Double.MIN_VALUE, 0.0, 0.0);
Assertions.assertNotEquals(x.hashCode(), y.hashCode());
@@ -415,7 +415,7 @@ public class QuaternionTest {
}
@Test
- public final void testQuaternionEquals() {
+ final void testQuaternionEquals() {
final double inc = 1e-5;
final Quaternion q1 = Quaternion.of(2, 1, -4, -2);
final Quaternion q2 = Quaternion.of(q1.getW() + inc, q1.getX(), q1.getY(), q1.getZ());
@@ -435,7 +435,7 @@ public class QuaternionTest {
}
@Test
- public final void testQuaternionEquals2() {
+ final void testQuaternionEquals2() {
final Quaternion q1 = Quaternion.of(1, 4, 2, 3);
final double gap = 1e-5;
final Quaternion q2 = Quaternion.of(1 + gap, 4 + gap, 2 + gap, 3 + gap);
@@ -446,7 +446,7 @@ public class QuaternionTest {
}
@Test
- public final void testIsUnit() {
+ final void testIsUnit() {
final Random r = new Random(48);
final int numberOfTrials = 1000;
for (int i = 0; i < numberOfTrials; i++) {
@@ -460,7 +460,7 @@ public class QuaternionTest {
}
@Test
- public final void testIsPure() {
+ final void testIsPure() {
final Quaternion q1 = Quaternion.of(0, 5, 4, 8);
Assertions.assertTrue(q1.isPure(EPS));
@@ -480,7 +480,7 @@ public class QuaternionTest {
}
@Test
- public final void testPositivePolarFormWhenScalarPositive() {
+ final void testPositivePolarFormWhenScalarPositive() {
Quaternion q = Quaternion.of(3, -3, -3, 3).positivePolarForm();
Quaternion expected = Quaternion.of(0.5, -0.5, -0.5, 0.5);
assertEquals(q, expected, EPS);
@@ -489,7 +489,7 @@ public class QuaternionTest {
}
@Test
- public final void testPositivePolarFormWhenScalarNegative() {
+ final void testPositivePolarFormWhenScalarNegative() {
Quaternion q = Quaternion.of(-3, 3, -3, 3).positivePolarForm();
Quaternion expected = Quaternion.of(0.5, -0.5, 0.5, -0.5);
assertEquals(q, expected, EPS);
@@ -498,7 +498,7 @@ public class QuaternionTest {
}
@Test
- public final void testPositivePolarFormWhenScalarPositiveAndNormalized() {
+ final void testPositivePolarFormWhenScalarPositiveAndNormalized() {
Quaternion q = Quaternion.of(123, 45, 67, 89).normalize().positivePolarForm();
Assertions.assertTrue(q.getW() >= 0);
@@ -506,7 +506,7 @@ public class QuaternionTest {
}
@Test
- public final void testPositivePolarFormWhenScalarNegativeAndNormalized() {
+ final void testPositivePolarFormWhenScalarNegativeAndNormalized() {
Quaternion q = Quaternion.of(123, 45, 67, 89).normalize().negate().positivePolarForm();
Assertions.assertTrue(q.getW() >= 0);
@@ -514,7 +514,7 @@ public class QuaternionTest {
}
@Test
- public void testNegate() {
+ void testNegate() {
final double a = -1;
final double b = 2;
final double c = -3;
@@ -530,7 +530,7 @@ public class QuaternionTest {
}
@Test
- public void testNegateNormalized() {
+ void testNegateNormalized() {
final double a = -1;
final double b = 2;
final double c = -3;
@@ -541,7 +541,7 @@ public class QuaternionTest {
}
@Test
- public void testNegatePositivePolarForm() {
+ void testNegatePositivePolarForm() {
final double a = -1;
final double b = 2;
final double c = -3;
@@ -553,7 +553,7 @@ public class QuaternionTest {
/* TODO remove dependency on Rotation
@Test
- public final void testPolarForm() {
+ final void testPolarForm() {
final Random r = new Random(48);
final int numberOfTrials = 1000;
for (int i = 0; i < numberOfTrials; i++) {
@@ -581,7 +581,7 @@ public class QuaternionTest {
}
*/
@Test
- public final void testInverse() {
+ final void testInverse() {
final Quaternion q = Quaternion.of(1.5, 4, 2, -2.5);
final Quaternion inverseQ = q.inverse();
@@ -606,7 +606,7 @@ public class QuaternionTest {
}
@Test
- public void testInverse_zeroNorm() {
+ void testInverse_zeroNorm() {
Quaternion q = Quaternion.of(0, 0, 0, 0);
Assertions.assertThrows(IllegalStateException.class,
q::inverse
@@ -614,7 +614,7 @@ public class QuaternionTest {
}
@Test
- public void testInverse_nanNorm() {
+ void testInverse_nanNorm() {
Quaternion q = Quaternion.of(Double.NaN, 0, 0, 0);
Assertions.assertThrows(IllegalStateException.class,
q::inverse
@@ -622,7 +622,7 @@ public class QuaternionTest {
}
@Test
- public void testInverse_positiveInfinityNorm() {
+ void testInverse_positiveInfinityNorm() {
Quaternion q = Quaternion.of(0, Double.POSITIVE_INFINITY, 0, 0);
Assertions.assertThrows(IllegalStateException.class,
q::inverse
@@ -630,7 +630,7 @@ public class QuaternionTest {
}
@Test
- public void testInverse_negativeInfinityNorm() {
+ void testInverse_negativeInfinityNorm() {
Quaternion q = Quaternion.of(0, 0, Double.NEGATIVE_INFINITY, 0);
Assertions.assertThrows(IllegalStateException.class,
q::inverse
@@ -638,7 +638,7 @@ public class QuaternionTest {
}
@Test
- public void testInverseNormalized() {
+ void testInverseNormalized() {
final Quaternion invQ = Quaternion.of(-1.2, 3.4, -5.6, -7.8).normalize().inverse();
final Quaternion q = invQ.inverse();
final Quaternion result = q.multiply(invQ);
@@ -646,7 +646,7 @@ public class QuaternionTest {
}
@Test
- public void testInversePositivePolarForm() {
+ void testInversePositivePolarForm() {
final Quaternion invQ = Quaternion.of(1.2, -3.4, 5.6, -7.8).positivePolarForm().inverse();
final Quaternion q = invQ.inverse();
final Quaternion result = q.multiply(invQ);
@@ -654,7 +654,7 @@ public class QuaternionTest {
}
@Test
- public final void testMultiply() {
+ final void testMultiply() {
final Quaternion q1 = Quaternion.of(1, 2, 3, 4);
final Quaternion q2 = Quaternion.of(4, 3, 2, 1);
final Quaternion actual = q1.multiply(q2);
@@ -667,14 +667,14 @@ public class QuaternionTest {
}
@Test
- public final void testParseFromToString() {
+ final void testParseFromToString() {
final Quaternion q = Quaternion.of(1.1, 2.2, 3.3, 4.4);
Quaternion parsed = Quaternion.parse(q.toString());
assertEquals(parsed, q, EPS);
}
@Test
- public final void testParseSpecials() {
+ final void testParseSpecials() {
Quaternion parsed = Quaternion.parse("[1e-5 Infinity NaN -0xa.cp0]");
Assertions.assertEquals(1e-5, parsed.getW(), EPS);
Assertions.assertTrue(Double.isInfinite(parsed.getX()));
@@ -683,56 +683,56 @@ public class QuaternionTest {
}
@Test
- public final void testParseMissingStart() {
+ final void testParseMissingStart() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> Quaternion.parse("1.0 2.0 3.0 4.0]")
);
}
@Test
- public final void testParseMissingEnd() {
+ final void testParseMissingEnd() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> Quaternion.parse("[1.0 2.0 3.0 4.0")
);
}
@Test
- public final void testParseMissingPart() {
+ final void testParseMissingPart() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> Quaternion.parse("[1.0 2.0 3.0 ]")
);
}
@Test
- public final void testParseInvalidScalar() {
+ final void testParseInvalidScalar() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> Quaternion.parse("[1.x 2.0 3.0 4.0]")
);
}
@Test
- public final void testParseInvalidI() {
+ final void testParseInvalidI() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> Quaternion.parse("[1.0 2.0x 3.0 4.0]")
);
}
@Test
- public final void testParseInvalidJ() {
+ final void testParseInvalidJ() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> Quaternion.parse("[1.0 2.0 3.0x 4.0]")
);
}
@Test
- public final void testParseInvalidK() {
+ final void testParseInvalidK() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> Quaternion.parse("[1.0 2.0 3.0 4.0x]")
);
}
@Test
- public final void testToString() {
+ final void testToString() {
final Quaternion q = Quaternion.of(1, 2, 3, 4);
Assertions.assertEquals("[1.0 2.0 3.0 4.0]", q.toString());
}
diff --git a/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/SlerpTest.java b/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/SlerpTest.java
index 71ebb5e..bcdbcbe 100644
--- a/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/SlerpTest.java
+++ b/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/SlerpTest.java
@@ -29,7 +29,7 @@ public class SlerpTest {
private static final double INV_SQRT_2 = 1.0 / SQRT_2;
@Test
- public void testSlerp_sphericalAlgorithm() {
+ void testSlerp_sphericalAlgorithm() {
// arrange
Quaternion q1 = createZRotation(0.75 * Math.PI);
Quaternion q2 = createZRotation(-0.75 * Math.PI);
@@ -47,7 +47,7 @@ public class SlerpTest {
}
@Test
- public void testSlerp_sphericalAlgorithm_allOutputsAreInPositivePolarForm() {
+ void testSlerp_sphericalAlgorithm_allOutputsAreInPositivePolarForm() {
// arrange
Quaternion q1 = createZRotation(0.75 * Math.PI);
Quaternion q2 = createZRotation(-0.75 * Math.PI);
@@ -69,7 +69,7 @@ public class SlerpTest {
}
@Test
- public void testSlerp_nonNormalizedInputs() {
+ void testSlerp_nonNormalizedInputs() {
// arrange
Quaternion q1 = createZRotation(0).multiply(10.0);
Quaternion q2 = createZRotation(Math.PI).multiply(0.2);
@@ -85,7 +85,7 @@ public class SlerpTest {
}
@Test
- public void testSlerp_linearAlgorithm() {
+ void testSlerp_linearAlgorithm() {
// arrange
Quaternion q1 = createZRotation(0.75 * Math.PI);
Quaternion q2 = createZRotation(0.76 * Math.PI);
@@ -101,7 +101,7 @@ public class SlerpTest {
}
@Test
- public void testSlerp_linearAlgorithm_allOutputsAreInPositivePolarForm() {
+ void testSlerp_linearAlgorithm_allOutputsAreInPositivePolarForm() {
// arrange
Quaternion q1 = createZRotation(0.75 * Math.PI);
Quaternion q2 = createZRotation(0.76 * Math.PI);
@@ -123,7 +123,7 @@ public class SlerpTest {
}
@Test
- public void testSlerp_identicalInputs() {
+ void testSlerp_identicalInputs() {
// arrange
Quaternion q1 = createZRotation(0);
Quaternion q2 = createZRotation(0);
@@ -139,7 +139,7 @@ public class SlerpTest {
}
@Test
- public void testSlerp_inputQuaternionsHaveMinusOneDotProduct() {
+ void testSlerp_inputQuaternionsHaveMinusOneDotProduct() {
// arrange
Quaternion q1 = createZRotation(0.5 * Math.PI);
Quaternion q2 = createZRotation(1.5 * Math.PI).conjugate(); // 3pi/2 around -z
@@ -157,7 +157,7 @@ public class SlerpTest {
}
@Test
- public void testSlerp_tOutsideOfZeroToOne() {
+ void testSlerp_tOutsideOfZeroToOne() {
// arrange
Quaternion q1 = createZRotation(0);
Quaternion q2 = createZRotation(0.25 * Math.PI);
@@ -175,7 +175,7 @@ public class SlerpTest {
}
@Test
- public void testVectorTransform_simple() {
+ void testVectorTransform_simple() {
// arrange
Quaternion q0 = Quaternion.of(1, 0, 0, 0); // rotation of zero
Quaternion q1 = Quaternion.of(0, 0, 0, 1); // pi rotation around +z
@@ -202,7 +202,7 @@ public class SlerpTest {
}
@Test
- public void testVectorTransform_multipleCombinations() {
+ void testVectorTransform_multipleCombinations() {
// arrange
Quaternion[] quaternions = {
// +x axis
@@ -280,7 +280,7 @@ public class SlerpTest {
}
@Test
- public void testVectorTransform_tOutsideOfZeroToOne_() {
+ void testVectorTransform_tOutsideOfZeroToOne_() {
// arrange
double angle1 = Math.PI * 0.25;
double angle2 = Math.PI * 0.75;
diff --git a/commons-numbers-rootfinder/src/test/java/org/apache/commons/numbers/rootfinder/BrentSolverTest.java b/commons-numbers-rootfinder/src/test/java/org/apache/commons/numbers/rootfinder/BrentSolverTest.java
index ab2afb6..aebd765 100644
--- a/commons-numbers-rootfinder/src/test/java/org/apache/commons/numbers/rootfinder/BrentSolverTest.java
+++ b/commons-numbers-rootfinder/src/test/java/org/apache/commons/numbers/rootfinder/BrentSolverTest.java
@@ -30,7 +30,7 @@ public class BrentSolverTest {
private static final double DEFAULT_FUNCTION_ACCURACY = 1e-15;
@Test
- public void testSinZero() {
+ void testSinZero() {
// The sinus function is behaved well around the root at pi. The second
// order derivative is zero, which means linar approximating methods will
// still converge quadratically.
@@ -56,7 +56,7 @@ public class BrentSolverTest {
}
@Test
- public void testQuinticZero() {
+ void testQuinticZero() {
// The quintic function has zeros at 0, +-0.5 and +-1.
// Around the root of 0 the function is well behaved, with a second derivative
// of zero a 0.
@@ -140,7 +140,7 @@ public class BrentSolverTest {
}
@Test
- public void testTooManyCalls() {
+ void testTooManyCalls() {
final DoubleUnaryOperator func = new QuinticFunction();
final BrentSolver solver = new BrentSolver(DEFAULT_ABSOLUTE_ACCURACY,
DEFAULT_RELATIVE_ACCURACY,
@@ -167,7 +167,7 @@ public class BrentSolverTest {
}
@Test
- public void testRootEndpoints() {
+ void testRootEndpoints() {
final DoubleUnaryOperator f = new Sin();
final BrentSolver solver = new BrentSolver(DEFAULT_ABSOLUTE_ACCURACY,
DEFAULT_RELATIVE_ACCURACY,
@@ -188,7 +188,7 @@ public class BrentSolverTest {
}
@Test
- public void testBadEndpoints() {
+ void testBadEndpoints() {
final DoubleUnaryOperator f = new Sin();
final BrentSolver solver = new BrentSolver(DEFAULT_ABSOLUTE_ACCURACY,
DEFAULT_RELATIVE_ACCURACY,
@@ -217,7 +217,7 @@ public class BrentSolverTest {
}
@Test
- public void testBadInitialGuess() {
+ void testBadInitialGuess() {
final DoubleUnaryOperator func = new QuinticFunction();
final BrentSolver solver = new BrentSolver(DEFAULT_ABSOLUTE_ACCURACY,
DEFAULT_RELATIVE_ACCURACY,
@@ -234,7 +234,7 @@ public class BrentSolverTest {
}
@Test
- public void testInitialGuess() {
+ void testInitialGuess() {
final DoubleUnaryOperator func = new QuinticFunction();
final BrentSolver solver = new BrentSolver(DEFAULT_ABSOLUTE_ACCURACY,
DEFAULT_RELATIVE_ACCURACY,
[commons-numbers] 07/08: Use assertTrue/False when testing the
equals method
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit 7b57fc870aa7b08f0460d2198f57c0f379630c8e
Author: aherbert <ah...@apache.org>
AuthorDate: Mon Jun 29 16:09:37 2020 +0100
Use assertTrue/False when testing the equals method
---
.../java/org/apache/commons/numbers/fraction/BigFractionTest.java | 2 +-
.../test/java/org/apache/commons/numbers/fraction/FractionTest.java | 4 ++--
2 files changed, 3 insertions(+), 3 deletions(-)
diff --git a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/BigFractionTest.java b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/BigFractionTest.java
index a457767..81e8774 100644
--- a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/BigFractionTest.java
+++ b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/BigFractionTest.java
@@ -625,7 +625,7 @@ public class BigFractionTest {
@Test
void testEqualsAndHashCode() {
final BigFraction zero = BigFraction.of(0, 1);
- Assertions.assertEquals(zero, zero);
+ Assertions.assertTrue(zero.equals(zero));
Assertions.assertFalse(zero.equals(null));
Assertions.assertFalse(zero.equals(new Object()));
Assertions.assertFalse(zero.equals(Double.valueOf(0)));
diff --git a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionTest.java b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionTest.java
index 0c5bc3e..f50eee0 100644
--- a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionTest.java
+++ b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionTest.java
@@ -463,8 +463,8 @@ public class FractionTest {
@Test
void testEqualsAndHashCode() {
final Fraction zero = Fraction.of(0, 1);
- Assertions.assertEquals(zero, zero);
- Assertions.assertNotEquals(zero, null);
+ Assertions.assertTrue(zero.equals(zero));
+ Assertions.assertFalse(zero.equals(null));
Assertions.assertFalse(zero.equals(new Object()));
Assertions.assertFalse(zero.equals(Double.valueOf(0)));
[commons-numbers] 05/08: Remove commented out code
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit d1b9542dac9a36d7a8ddf3dcc313553b28a6a12c
Author: aherbert <ah...@apache.org>
AuthorDate: Mon Jun 29 15:59:25 2020 +0100
Remove commented out code
---
pom.xml | 1 -
1 file changed, 1 deletion(-)
diff --git a/pom.xml b/pom.xml
index 9590f66..aa77692 100644
--- a/pom.xml
+++ b/pom.xml
@@ -207,7 +207,6 @@
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<compilerArgs>
- <!-- <arg>-verbose</arg> -->
<arg>-Xlint:all,-options,-path</arg>
</compilerArgs>
</configuration>
[commons-numbers] 04/08: Fix SonarCloud: Use assertNotEquals
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit 4077b9ab4d578d4bce6994bafa6b90a4fa4bee7a
Author: aherbert <ah...@apache.org>
AuthorDate: Mon Jun 29 15:56:14 2020 +0100
Fix SonarCloud: Use assertNotEquals
---
.../apache/commons/numbers/combinatorics/FactorialDoubleTest.java | 6 +++---
.../org/apache/commons/numbers/quaternion/QuaternionTest.java | 8 ++++----
2 files changed, 7 insertions(+), 7 deletions(-)
diff --git a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialDoubleTest.java b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialDoubleTest.java
index 9862b76..414ba0d 100644
--- a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialDoubleTest.java
+++ b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialDoubleTest.java
@@ -39,15 +39,15 @@ public class FactorialDoubleTest {
@Test
void testLargestFactorialDouble() {
final int n = 170;
- Assertions.assertTrue(
- Double.POSITIVE_INFINITY != FactorialDouble.create().value(n), n + "!");
+ Assertions.assertNotEquals(
+ Double.POSITIVE_INFINITY, FactorialDouble.create().value(n), () -> n + "!");
}
@Test
void testFactorialDoubleTooLarge() {
final int n = 171;
Assertions.assertEquals(
- Double.POSITIVE_INFINITY, FactorialDouble.create().value(n), 0d, n + "!");
+ Double.POSITIVE_INFINITY, FactorialDouble.create().value(n), () -> n + "!");
}
@Test
diff --git a/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/QuaternionTest.java b/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/QuaternionTest.java
index 4ea8545..e3022ce 100644
--- a/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/QuaternionTest.java
+++ b/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/QuaternionTest.java
@@ -395,22 +395,22 @@ public class QuaternionTest {
x = Quaternion.of(0.0, 0.0, 0.0, 0.0);
y = Quaternion.of(-0.0, 0.0, 0.0, 0.0);
- Assertions.assertTrue(x.hashCode() != y.hashCode());
+ Assertions.assertNotEquals(x.hashCode(), y.hashCode());
Assertions.assertNotEquals(x, y, msg);
x = Quaternion.of(0.0, 0.0, 0.0, 0.0);
y = Quaternion.of(0.0, -0.0, 0.0, 0.0);
- Assertions.assertTrue(x.hashCode() != y.hashCode());
+ Assertions.assertNotEquals(x.hashCode(), y.hashCode());
Assertions.assertNotEquals(x, y, msg);
x = Quaternion.of(0.0, 0.0, 0.0, 0.0);
y = Quaternion.of(0.0, 0.0, -0.0, 0.0);
- Assertions.assertTrue(x.hashCode() != y.hashCode());
+ Assertions.assertNotEquals(x.hashCode(), y.hashCode());
Assertions.assertNotEquals(x, y, msg);
x = Quaternion.of(0.0, 0.0, 0.0, 0.0);
y = Quaternion.of(0.0, 0.0, 0.0, -0.0);
- Assertions.assertTrue(x.hashCode() != y.hashCode());
+ Assertions.assertNotEquals(x.hashCode(), y.hashCode());
Assertions.assertNotEquals(x, y, msg);
}
[commons-numbers] 02/08: Add assertions to test of useless cache
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit 7983d34b7b3fab4dbaf21c04dad427555b498539
Author: aherbert <ah...@apache.org>
AuthorDate: Mon Jun 29 15:44:36 2020 +0100
Add assertions to test of useless cache
---
.../commons/numbers/combinatorics/LogFactorialTest.java | 13 +++++++++----
1 file changed, 9 insertions(+), 4 deletions(-)
diff --git a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogFactorialTest.java b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogFactorialTest.java
index 568335d..e7c84ce 100644
--- a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogFactorialTest.java
+++ b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogFactorialTest.java
@@ -84,15 +84,20 @@ public class LogFactorialTest {
void testZeroCache() {
// Ensure that no exception is thrown.
final LogFactorial f = LogFactorial.create().withCache(0);
- Assertions.assertEquals(0, f.value(0), 0d);
- Assertions.assertEquals(0, f.value(1), 0d);
+ Assertions.assertEquals(0, f.value(0));
+ Assertions.assertEquals(0, f.value(1));
}
@Test
void testUselessCache() {
// Ensure that no exception is thrown.
- LogFactorial.create().withCache(1);
- LogFactorial.create().withCache(2);
+ LogFactorial f = LogFactorial.create().withCache(1);
+ Assertions.assertEquals(0, f.value(0));
+ Assertions.assertEquals(0, f.value(1));
+
+ f = LogFactorial.create().withCache(2);
+ Assertions.assertEquals(0, f.value(0));
+ Assertions.assertEquals(0, f.value(1));
}
@Test