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-statistics.git
commit 60241f5b155b726801faff96e93ccb64e1cee34f Author: Alex Herbert <[email protected]> AuthorDate: Fri Jun 14 21:32:49 2019 +0100 STATISTICS-19: Replace Assert with Assertions. Update String.format messages to lambdas. --- .../AbstractContinuousDistributionTest.java | 6 +-- .../AbstractDiscreteDistributionTest.java | 38 ++++++++--------- .../distribution/BetaDistributionTest.java | 33 +++++++-------- .../distribution/BinomialDistributionTest.java | 24 +++++------ .../distribution/CauchyDistributionTest.java | 13 +++--- .../distribution/ChiSquaredDistributionTest.java | 14 +++---- .../ConstantContinuousDistributionTest.java | 10 ++--- .../ContinuousDistributionAbstractTest.java | 5 +-- .../DiscreteDistributionAbstractTest.java | 49 ++++++++++++---------- .../distribution/ExponentialDistributionTest.java | 29 +++++++------ .../statistics/distribution/FDistributionTest.java | 27 ++++++------ .../distribution/GammaDistributionTest.java | 47 ++++++++++----------- .../distribution/GeometricDistributionTest.java | 10 ++--- .../distribution/GumbelDistributionTest.java | 12 +++--- .../HypergeometricDistributionTest.java | 41 +++++++++--------- .../distribution/LaplaceDistributionTest.java | 12 +++--- .../distribution/LevyDistributionTest.java | 12 +++--- .../distribution/LogNormalDistributionTest.java | 33 +++++++-------- .../distribution/LogisticsDistributionTest.java | 12 +++--- .../distribution/NakagamiDistributionTest.java | 12 +++--- .../distribution/NormalDistributionTest.java | 45 ++++++++++---------- .../distribution/ParetoDistributionTest.java | 27 ++++++------ .../distribution/PascalDistributionTest.java | 10 ++--- .../distribution/PoissonDistributionTest.java | 43 +++++++++---------- .../statistics/distribution/TDistributionTest.java | 19 ++++----- .../commons/statistics/distribution/TestUtils.java | 25 ++++++----- .../distribution/TriangularDistributionTest.java | 17 ++++---- .../UniformContinuousDistributionTest.java | 19 ++++----- .../UniformDiscreteDistributionTest.java | 21 +++++----- .../distribution/WeibullDistributionTest.java | 15 ++++--- .../distribution/ZipfDistributionTest.java | 5 +-- 31 files changed, 333 insertions(+), 352 deletions(-) diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/AbstractContinuousDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/AbstractContinuousDistributionTest.java index f28051d..6251a64 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/AbstractContinuousDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/AbstractContinuousDistributionTest.java @@ -19,7 +19,7 @@ package org.apache.commons.statistics.distribution; import org.apache.commons.math3.analysis.UnivariateFunction; import org.apache.commons.math3.analysis.integration.RombergIntegrator; import org.apache.commons.math3.analysis.integration.UnivariateIntegrator; -import org.junit.Assert; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; /** Various tests related to MATH-699. */ @@ -104,7 +104,7 @@ public class AbstractContinuousDistributionTest { }; final double expected = x1; final double actual = distribution.inverseCumulativeProbability(p12); - Assert.assertEquals("", expected, actual, 1e-8); + Assertions.assertEquals(expected, actual, 1e-8); } @Test @@ -203,6 +203,6 @@ public class AbstractContinuousDistributionTest { }; final double expected = x2; final double actual = distribution.inverseCumulativeProbability(p23); - Assert.assertEquals("", expected, actual, 1e-8); + Assertions.assertEquals(expected, actual, 1e-8); } } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/AbstractDiscreteDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/AbstractDiscreteDistributionTest.java index 9c59afe..cbb42ab 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/AbstractDiscreteDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/AbstractDiscreteDistributionTest.java @@ -16,7 +16,7 @@ */ package org.apache.commons.statistics.distribution; -import org.junit.Assert; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -30,30 +30,30 @@ public class AbstractDiscreteDistributionTest { @Test public void testInverseCumulativeProbabilityMethod() { double precision = 0.000000000000001; - Assert.assertEquals(1, diceDistribution.inverseCumulativeProbability(0)); - Assert.assertEquals(1, diceDistribution.inverseCumulativeProbability((1d - Double.MIN_VALUE) / 6d)); - Assert.assertEquals(2, diceDistribution.inverseCumulativeProbability((1d + precision) / 6d)); - Assert.assertEquals(2, diceDistribution.inverseCumulativeProbability((2d - Double.MIN_VALUE) / 6d)); - Assert.assertEquals(3, diceDistribution.inverseCumulativeProbability((2d + precision) / 6d)); - Assert.assertEquals(3, diceDistribution.inverseCumulativeProbability((3d - Double.MIN_VALUE) / 6d)); - Assert.assertEquals(4, diceDistribution.inverseCumulativeProbability((3d + precision) / 6d)); - Assert.assertEquals(4, diceDistribution.inverseCumulativeProbability((4d - Double.MIN_VALUE) / 6d)); - Assert.assertEquals(5, diceDistribution.inverseCumulativeProbability((4d + precision) / 6d)); - Assert.assertEquals(5, diceDistribution.inverseCumulativeProbability((5d - precision) / 6d)); //Can't use Double.MIN - Assert.assertEquals(6, diceDistribution.inverseCumulativeProbability((5d + precision) / 6d)); - Assert.assertEquals(6, diceDistribution.inverseCumulativeProbability((6d - precision) / 6d)); //Can't use Double.MIN - Assert.assertEquals(6, diceDistribution.inverseCumulativeProbability(1d)); + Assertions.assertEquals(1, diceDistribution.inverseCumulativeProbability(0)); + Assertions.assertEquals(1, diceDistribution.inverseCumulativeProbability((1d - Double.MIN_VALUE) / 6d)); + Assertions.assertEquals(2, diceDistribution.inverseCumulativeProbability((1d + precision) / 6d)); + Assertions.assertEquals(2, diceDistribution.inverseCumulativeProbability((2d - Double.MIN_VALUE) / 6d)); + Assertions.assertEquals(3, diceDistribution.inverseCumulativeProbability((2d + precision) / 6d)); + Assertions.assertEquals(3, diceDistribution.inverseCumulativeProbability((3d - Double.MIN_VALUE) / 6d)); + Assertions.assertEquals(4, diceDistribution.inverseCumulativeProbability((3d + precision) / 6d)); + Assertions.assertEquals(4, diceDistribution.inverseCumulativeProbability((4d - Double.MIN_VALUE) / 6d)); + Assertions.assertEquals(5, diceDistribution.inverseCumulativeProbability((4d + precision) / 6d)); + Assertions.assertEquals(5, diceDistribution.inverseCumulativeProbability((5d - precision) / 6d)); //Can't use Double.MIN + Assertions.assertEquals(6, diceDistribution.inverseCumulativeProbability((5d + precision) / 6d)); + Assertions.assertEquals(6, diceDistribution.inverseCumulativeProbability((6d - precision) / 6d)); //Can't use Double.MIN + Assertions.assertEquals(6, diceDistribution.inverseCumulativeProbability(1d)); } @Test public void testCumulativeProbabilitiesSingleArguments() { for (int i = 1; i < 7; i++) { - Assert.assertEquals(p * i, + Assertions.assertEquals(p * i, diceDistribution.cumulativeProbability(i), Double.MIN_VALUE); } - Assert.assertEquals(0.0, + Assertions.assertEquals(0.0, diceDistribution.cumulativeProbability(0), Double.MIN_VALUE); - Assert.assertEquals(1.0, + Assertions.assertEquals(1.0, diceDistribution.cumulativeProbability(7), Double.MIN_VALUE); } @@ -63,13 +63,13 @@ public class AbstractDiscreteDistributionTest { int upper = 6; for (int i = 0; i < 2; i++) { // cum(0,6) = p(0 < X <= 6) = 1, cum(1,5) = 4/6, cum(2,4) = 2/6 - Assert.assertEquals(1 - p * 2 * i, + Assertions.assertEquals(1 - p * 2 * i, diceDistribution.probability(lower, upper), 1E-12); lower++; upper--; } for (int i = 0; i < 6; i++) { - Assert.assertEquals(p, diceDistribution.probability(i, i + 1), 1E-12); + Assertions.assertEquals(p, diceDistribution.probability(i, i + 1), 1E-12); } } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/BetaDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/BetaDistributionTest.java index 8bb4c91..33ed834 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/BetaDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/BetaDistributionTest.java @@ -22,7 +22,7 @@ import org.apache.commons.rng.simple.RandomSource; import org.apache.commons.rng.UniformRandomProvider; import org.apache.commons.math3.stat.StatUtils; import org.apache.commons.math3.stat.inference.GTest; -import org.junit.Assert; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; public class BetaDistributionTest { @@ -152,11 +152,11 @@ public class BetaDistributionTest { private void checkCumulative(double alpha, double beta, double[] x, double[] cumes) { BetaDistribution d = new BetaDistribution(alpha, beta); for (int i = 0; i < x.length; i++) { - Assert.assertEquals(cumes[i], d.cumulativeProbability(x[i]), 1e-8); + Assertions.assertEquals(cumes[i], d.cumulativeProbability(x[i]), 1e-8); } for (int i = 1; i < x.length - 1; i++) { - Assert.assertEquals(x[i], d.inverseCumulativeProbability(cumes[i]), 1e-5); + Assertions.assertEquals(x[i], d.inverseCumulativeProbability(cumes[i]), 1e-5); } } @@ -294,7 +294,9 @@ public class BetaDistributionTest { private void checkDensity(double alpha, double beta, double[] x, double[] expected) { BetaDistribution d = new BetaDistribution(alpha, beta); for (int i = 0; i < x.length; i++) { - Assert.assertEquals(String.format("density at x=%.1f for alpha=%.1f, beta=%.1f", x[i], alpha, beta), expected[i], d.density(x[i]), 1e-5); + final int index = i; + Assertions.assertEquals(expected[i], d.density(x[i]), 1e-5, + () -> String.format("density at x=%.1f for alpha=%.1f, beta=%.1f", x[index], alpha, beta)); } } @@ -304,12 +306,12 @@ public class BetaDistributionTest { BetaDistribution dist; dist = new BetaDistribution(1, 1); - Assert.assertEquals(0.5, dist.getMean(), tol); - Assert.assertEquals(1.0 / 12.0, dist.getVariance(), tol); + Assertions.assertEquals(0.5, dist.getMean(), tol); + Assertions.assertEquals(1.0 / 12.0, dist.getVariance(), tol); dist = new BetaDistribution(2, 5); - Assert.assertEquals(2.0 / 7.0, dist.getMean(), tol); - Assert.assertEquals(10.0 / (49.0 * 8.0), dist.getVariance(), tol); + Assertions.assertEquals(2.0 / 7.0, dist.getMean(), tol); + Assertions.assertEquals(10.0 / (49.0 * 8.0), dist.getVariance(), tol); } @Test @@ -324,13 +326,10 @@ public class BetaDistributionTest { betaDistribution.createSampler(rng)); Arrays.sort(observed); - final String distribution = String.format("Beta(%.2f, %.2f)", alpha, beta); - Assert.assertEquals(String.format("E[%s]", distribution), - betaDistribution.getMean(), - StatUtils.mean(observed), EPSILON); - Assert.assertEquals(String.format("Var[%s]", distribution), - betaDistribution.getVariance(), - StatUtils.variance(observed), EPSILON); + Assertions.assertEquals(betaDistribution.getMean(), StatUtils.mean(observed), + EPSILON, () -> String.format("E[Beta(%.2f, %.2f)]", alpha, beta)); + Assertions.assertEquals(betaDistribution.getVariance(), StatUtils.variance(observed), + EPSILON, () -> String.format("Var[Beta(%.2f, %.2f)]", alpha, beta)); } } } @@ -350,8 +349,8 @@ public class BetaDistributionTest { final double[] observed = AbstractContinuousDistribution.sample(numSamples, sampler); final double gT = gTest(betaDistribution, observed); - Assert.assertFalse("G goodness-of-fit (" + gT + ") test rejected null at alpha = " + level, - gT < level); + Assertions.assertFalse(gT < level, + () -> "G goodness-of-fit (" + gT + ") test rejected null at alpha = " + level); } } } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/BinomialDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/BinomialDistributionTest.java index f24a803..b322a21 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/BinomialDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/BinomialDistributionTest.java @@ -16,7 +16,7 @@ */ package org.apache.commons.statistics.distribution; -import org.junit.Assert; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -108,8 +108,8 @@ public class BinomialDistributionTest extends DiscreteDistributionAbstractTest { verifyDensities(); verifyCumulativeProbabilities(); verifyInverseCumulativeProbabilities(); - Assert.assertEquals(dist.getSupportLowerBound(), 0); - Assert.assertEquals(dist.getSupportUpperBound(), 0); + Assertions.assertEquals(dist.getSupportLowerBound(), 0); + Assertions.assertEquals(dist.getSupportUpperBound(), 0); } /** Test degenerate case p = 1 */ @@ -126,8 +126,8 @@ public class BinomialDistributionTest extends DiscreteDistributionAbstractTest { verifyDensities(); verifyCumulativeProbabilities(); verifyInverseCumulativeProbabilities(); - Assert.assertEquals(dist.getSupportLowerBound(), 5); - Assert.assertEquals(dist.getSupportUpperBound(), 5); + Assertions.assertEquals(dist.getSupportLowerBound(), 5); + Assertions.assertEquals(dist.getSupportUpperBound(), 5); } /** Test degenerate case n = 0 */ @@ -144,8 +144,8 @@ public class BinomialDistributionTest extends DiscreteDistributionAbstractTest { verifyDensities(); verifyCumulativeProbabilities(); verifyInverseCumulativeProbabilities(); - Assert.assertEquals(dist.getSupportLowerBound(), 0); - Assert.assertEquals(dist.getSupportUpperBound(), 0); + Assertions.assertEquals(dist.getSupportLowerBound(), 0); + Assertions.assertEquals(dist.getSupportUpperBound(), 0); } @Test @@ -154,12 +154,12 @@ public class BinomialDistributionTest extends DiscreteDistributionAbstractTest { BinomialDistribution dist; dist = new BinomialDistribution(10, 0.5); - Assert.assertEquals(10d * 0.5d, dist.getMean(), tol); - Assert.assertEquals(10d * 0.5d * 0.5d, dist.getVariance(), tol); + Assertions.assertEquals(10d * 0.5d, dist.getMean(), tol); + Assertions.assertEquals(10d * 0.5d * 0.5d, dist.getVariance(), tol); dist = new BinomialDistribution(30, 0.3); - Assert.assertEquals(30d * 0.3d, dist.getMean(), tol); - Assert.assertEquals(30d * 0.3d * (1d - 0.3d), dist.getVariance(), tol); + Assertions.assertEquals(30d * 0.3d, dist.getMean(), tol); + Assertions.assertEquals(30d * 0.3d * (1d - 0.3d), dist.getVariance(), tol); } @Test @@ -171,7 +171,7 @@ public class BinomialDistributionTest extends DiscreteDistributionAbstractTest { for (int trials = 500000; trials < 20000000; trials += 100000) { BinomialDistribution dist = new BinomialDistribution(trials, 0.5); int p = dist.inverseCumulativeProbability(0.5); - Assert.assertEquals(trials / 2, p); + Assertions.assertEquals(trials / 2, p); } } } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/CauchyDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/CauchyDistributionTest.java index 35b482e..7b44bfd 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/CauchyDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/CauchyDistributionTest.java @@ -17,7 +17,6 @@ package org.apache.commons.statistics.distribution; -import org.junit.Assert; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -80,13 +79,13 @@ public class CauchyDistributionTest extends ContinuousDistributionAbstractTest { @Test public void testMedian() { CauchyDistribution distribution = (CauchyDistribution) getDistribution(); - Assert.assertEquals(1.2, distribution.getMedian(), 0.0); + Assertions.assertEquals(1.2, distribution.getMedian(), 0.0); } @Test public void testScale() { CauchyDistribution distribution = (CauchyDistribution) getDistribution(); - Assert.assertEquals(2.1, distribution.getScale(), 0.0); + Assertions.assertEquals(2.1, distribution.getScale(), 0.0); } @Test @@ -103,11 +102,11 @@ public class CauchyDistributionTest extends ContinuousDistributionAbstractTest { CauchyDistribution dist; dist = new CauchyDistribution(10.2, 0.15); - Assert.assertTrue(Double.isNaN(dist.getMean())); - Assert.assertTrue(Double.isNaN(dist.getVariance())); + Assertions.assertTrue(Double.isNaN(dist.getMean())); + Assertions.assertTrue(Double.isNaN(dist.getVariance())); dist = new CauchyDistribution(23.12, 2.12); - Assert.assertTrue(Double.isNaN(dist.getMean())); - Assert.assertTrue(Double.isNaN(dist.getVariance())); + Assertions.assertTrue(Double.isNaN(dist.getMean())); + Assertions.assertTrue(Double.isNaN(dist.getVariance())); } } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ChiSquaredDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ChiSquaredDistributionTest.java index 4ad008b..3943b59 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ChiSquaredDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ChiSquaredDistributionTest.java @@ -17,7 +17,7 @@ package org.apache.commons.statistics.distribution; -import org.junit.Assert; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -98,7 +98,7 @@ public class ChiSquaredDistributionTest extends ContinuousDistributionAbstractTe @Test public void testDfAccessors() { ChiSquaredDistribution distribution = (ChiSquaredDistribution) getDistribution(); - Assert.assertEquals(5d, distribution.getDegreesOfFreedom(), Double.MIN_VALUE); + Assertions.assertEquals(5d, distribution.getDegreesOfFreedom(), Double.MIN_VALUE); } @Test @@ -117,7 +117,7 @@ public class ChiSquaredDistributionTest extends ContinuousDistributionAbstractTe private void checkDensity(double df, double[] x, double[] expected) { ChiSquaredDistribution d = new ChiSquaredDistribution(df); for (int i = 0; i < x.length; i++) { - Assert.assertEquals(expected[i], d.density(x[i]), 1e-5); + Assertions.assertEquals(expected[i], d.density(x[i]), 1e-5); } } @@ -127,11 +127,11 @@ public class ChiSquaredDistributionTest extends ContinuousDistributionAbstractTe ChiSquaredDistribution dist; dist = new ChiSquaredDistribution(1500); - Assert.assertEquals(1500, dist.getMean(), tol); - Assert.assertEquals(3000, dist.getVariance(), tol); + Assertions.assertEquals(1500, dist.getMean(), tol); + Assertions.assertEquals(3000, dist.getVariance(), tol); dist = new ChiSquaredDistribution(1.12); - Assert.assertEquals(1.12, dist.getMean(), tol); - Assert.assertEquals(2.24, dist.getVariance(), tol); + Assertions.assertEquals(1.12, dist.getMean(), tol); + Assertions.assertEquals(2.24, dist.getVariance(), tol); } } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ConstantContinuousDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ConstantContinuousDistributionTest.java index 4305cf3..e9858f2 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ConstantContinuousDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ConstantContinuousDistributionTest.java @@ -17,7 +17,7 @@ package org.apache.commons.statistics.distribution; -import org.junit.Assert; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -65,7 +65,7 @@ public class ConstantContinuousDistributionTest extends ContinuousDistributionAb public void testInverseCumulativeProbabilities() { ContinuousDistribution dist = getDistribution(); for (double x : getCumulativeTestValues()) { - Assert.assertEquals(1, dist.inverseCumulativeProbability(x), 0); + Assertions.assertEquals(1, dist.inverseCumulativeProbability(x), 0); } } @@ -76,8 +76,8 @@ public class ConstantContinuousDistributionTest extends ContinuousDistributionAb ConstantContinuousDistribution dist; dist = new ConstantContinuousDistribution(-1); - Assert.assertEquals(-1, dist.getMean(), 0d); - Assert.assertEquals(0, dist.getVariance(), 0d); + Assertions.assertEquals(-1, dist.getMean(), 0d); + Assertions.assertEquals(0, dist.getVariance(), 0d); } @Test @@ -86,7 +86,7 @@ public class ConstantContinuousDistributionTest extends ContinuousDistributionAb final double value = 12.345; final ContinuousDistribution.Sampler sampler = new ConstantContinuousDistribution(value).createSampler(null); for (int i = 0; i < 10; i++) { - Assert.assertEquals(value, sampler.sample(), 0); + Assertions.assertEquals(value, sampler.sample(), 0); } } } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ContinuousDistributionAbstractTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ContinuousDistributionAbstractTest.java index a534962..a7532f2 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ContinuousDistributionAbstractTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ContinuousDistributionAbstractTest.java @@ -24,7 +24,6 @@ import org.apache.commons.math3.analysis.UnivariateFunction; import org.apache.commons.math3.analysis.integration.BaseAbstractUnivariateIntegrator; import org.apache.commons.math3.analysis.integration.IterativeLegendreGaussIntegrator; import org.apache.commons.rng.simple.RandomSource; -import org.junit.Assert; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.Assertions; @@ -188,7 +187,7 @@ public abstract class ContinuousDistributionAbstractTest { } catch (IllegalArgumentException e) { continue; } - Assert.fail("distribution.probability(double, double) should have thrown an exception that second argument is too large"); + Assertions.fail("distribution.probability(double, double) should have thrown an exception that second argument is too large"); } } } @@ -357,7 +356,7 @@ public abstract class ContinuousDistributionAbstractTest { } Collections.sort(integrationTestPoints); for (int i = 1; i < integrationTestPoints.size(); i++) { - Assert.assertEquals(distribution.probability(integrationTestPoints.get(0), integrationTestPoints.get(i)), + Assertions.assertEquals(distribution.probability(integrationTestPoints.get(0), integrationTestPoints.get(i)), integrator.integrate(1000000, // Triangle integrals are very slow to converge d, integrationTestPoints.get(0), integrationTestPoints.get(i)), tol); diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/DiscreteDistributionAbstractTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/DiscreteDistributionAbstractTest.java index 8450bdd..0a0c61a 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/DiscreteDistributionAbstractTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/DiscreteDistributionAbstractTest.java @@ -17,7 +17,6 @@ package org.apache.commons.statistics.distribution; import org.apache.commons.rng.simple.RandomSource; -import org.junit.Assert; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; @@ -153,9 +152,10 @@ public abstract class DiscreteDistributionAbstractTest { */ protected void verifyDensities() { for (int i = 0; i < densityTestPoints.length; i++) { - Assert.assertEquals("Incorrect density value returned for " + densityTestPoints[i], - densityTestValues[i], - distribution.probability(densityTestPoints[i]), getTolerance()); + final int testPoint = densityTestPoints[i]; + Assertions.assertEquals(densityTestValues[i], + distribution.probability(testPoint), getTolerance(), + () -> "Incorrect density value returned for " + testPoint); } } @@ -166,9 +166,10 @@ public abstract class DiscreteDistributionAbstractTest { protected void verifyLogDensities() { for (int i = 0; i < densityTestPoints.length; i++) { // FIXME: when logProbability methods are added to DiscreteDistribution in 4.0, remove cast below - Assert.assertEquals("Incorrect log density value returned for " + densityTestPoints[i], - logDensityTestValues[i], - ((AbstractDiscreteDistribution) distribution).logProbability(densityTestPoints[i]), tolerance); + final int testPoint = densityTestPoints[i]; + Assertions.assertEquals(logDensityTestValues[i], + ((AbstractDiscreteDistribution) distribution).logProbability(testPoint), tolerance, + () -> "Incorrect log density value returned for " + testPoint); } } @@ -178,9 +179,10 @@ public abstract class DiscreteDistributionAbstractTest { */ protected void verifyCumulativeProbabilities() { for (int i = 0; i < cumulativeTestPoints.length; i++) { - Assert.assertEquals("Incorrect cumulative probability value returned for " + cumulativeTestPoints[i], - cumulativeTestValues[i], - distribution.cumulativeProbability(cumulativeTestPoints[i]), getTolerance()); + final int testPoint = cumulativeTestPoints[i]; + Assertions.assertEquals(cumulativeTestValues[i], + distribution.cumulativeProbability(testPoint), getTolerance(), + () -> "Incorrect cumulative probability value returned for " + testPoint); } } @@ -191,9 +193,10 @@ public abstract class DiscreteDistributionAbstractTest { */ protected void verifyInverseCumulativeProbabilities() { for (int i = 0; i < inverseCumulativeTestPoints.length; i++) { - Assert.assertEquals("Incorrect inverse cumulative probability value returned for " + - inverseCumulativeTestPoints[i], inverseCumulativeTestValues[i], - distribution.inverseCumulativeProbability(inverseCumulativeTestPoints[i])); + final double testPoint = inverseCumulativeTestPoints[i]; + Assertions.assertEquals(inverseCumulativeTestValues[i], + distribution.inverseCumulativeProbability(testPoint), + () -> "Incorrect inverse cumulative probability value returned for " + testPoint); } } @@ -238,20 +241,20 @@ public abstract class DiscreteDistributionAbstractTest { @Test public void testConsistencyAtSupportBounds() { final int lower = distribution.getSupportLowerBound(); - Assert.assertEquals("Cumulative probability mmust be 0 below support lower bound.", - 0.0, distribution.cumulativeProbability(lower - 1), 0.0); - Assert.assertEquals("Cumulative probability of support lower bound must be equal to probability mass at this point.", - distribution.probability(lower), distribution.cumulativeProbability(lower), getTolerance()); - Assert.assertEquals("Inverse cumulative probability of 0 must be equal to support lower bound.", - lower, distribution.inverseCumulativeProbability(0.0)); + Assertions.assertEquals(0.0, distribution.cumulativeProbability(lower - 1), 0.0, + "Cumulative probability mmust be 0 below support lower bound."); + Assertions.assertEquals(distribution.probability(lower), distribution.cumulativeProbability(lower), getTolerance(), + "Cumulative probability of support lower bound must be equal to probability mass at this point."); + Assertions.assertEquals(lower, distribution.inverseCumulativeProbability(0.0), + "Inverse cumulative probability of 0 must be equal to support lower bound."); final int upper = distribution.getSupportUpperBound(); if (upper != Integer.MAX_VALUE) { - Assert.assertEquals("Cumulative probability of support upper bound must be equal to 1.", - 1.0, distribution.cumulativeProbability(upper), 0.0); + Assertions.assertEquals(1.0, distribution.cumulativeProbability(upper), 0.0, + "Cumulative probability of support upper bound must be equal to 1."); } - Assert.assertEquals("Inverse cumulative probability of 1 must be equal to support upper bound.", - upper, distribution.inverseCumulativeProbability(1.0)); + Assertions.assertEquals(upper, distribution.inverseCumulativeProbability(1.0), + "Inverse cumulative probability of 1 must be equal to support upper bound."); } @Test diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ExponentialDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ExponentialDistributionTest.java index e9e0e44..da5e271 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ExponentialDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ExponentialDistributionTest.java @@ -17,7 +17,6 @@ package org.apache.commons.statistics.distribution; import org.apache.commons.numbers.core.Precision; -import org.junit.Assert; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -86,31 +85,31 @@ public class ExponentialDistributionTest extends ContinuousDistributionAbstractT @Test public void testCumulativeProbability2() { double actual = getDistribution().probability(0.25, 0.75); - Assert.assertEquals(0.0905214, actual, 10e-4); + Assertions.assertEquals(0.0905214, actual, 10e-4); } @Test public void testDensity() { ExponentialDistribution d1 = new ExponentialDistribution(1); - Assert.assertTrue(Precision.equals(0.0, d1.density(-1e-9), 1)); - Assert.assertTrue(Precision.equals(1.0, d1.density(0.0), 1)); - Assert.assertTrue(Precision.equals(0.0, d1.density(1000.0), 1)); - Assert.assertTrue(Precision.equals(Math.exp(-1), d1.density(1.0), 1)); - Assert.assertTrue(Precision.equals(Math.exp(-2), d1.density(2.0), 1)); + Assertions.assertTrue(Precision.equals(0.0, d1.density(-1e-9), 1)); + Assertions.assertTrue(Precision.equals(1.0, d1.density(0.0), 1)); + Assertions.assertTrue(Precision.equals(0.0, d1.density(1000.0), 1)); + Assertions.assertTrue(Precision.equals(Math.exp(-1), d1.density(1.0), 1)); + Assertions.assertTrue(Precision.equals(Math.exp(-2), d1.density(2.0), 1)); ExponentialDistribution d2 = new ExponentialDistribution(3); - Assert.assertTrue(Precision.equals(1 / 3.0, d2.density(0.0), 1)); + Assertions.assertTrue(Precision.equals(1 / 3.0, d2.density(0.0), 1)); // computed using print(dexp(1, rate=1/3), digits=10) in R 2.5 - Assert.assertEquals(0.2388437702, d2.density(1.0), 1e-8); + Assertions.assertEquals(0.2388437702, d2.density(1.0), 1e-8); // computed using print(dexp(2, rate=1/3), digits=10) in R 2.5 - Assert.assertEquals(0.1711390397, d2.density(2.0), 1e-8); + Assertions.assertEquals(0.1711390397, d2.density(2.0), 1e-8); } @Test public void testMeanAccessors() { ExponentialDistribution distribution = (ExponentialDistribution) getDistribution(); - Assert.assertEquals(5d, distribution.getMean(), Double.MIN_VALUE); + Assertions.assertEquals(5d, distribution.getMean(), Double.MIN_VALUE); } @Test @@ -124,11 +123,11 @@ public class ExponentialDistributionTest extends ContinuousDistributionAbstractT ExponentialDistribution dist; dist = new ExponentialDistribution(11d); - Assert.assertEquals(11d, dist.getMean(), tol); - Assert.assertEquals(11d * 11d, dist.getVariance(), tol); + Assertions.assertEquals(11d, dist.getMean(), tol); + Assertions.assertEquals(11d * 11d, dist.getVariance(), tol); dist = new ExponentialDistribution(10.5d); - Assert.assertEquals(10.5d, dist.getMean(), tol); - Assert.assertEquals(10.5d * 10.5d, dist.getVariance(), tol); + Assertions.assertEquals(10.5d, dist.getMean(), tol); + Assertions.assertEquals(10.5d * 10.5d, dist.getVariance(), tol); } } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/FDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/FDistributionTest.java index c3045dc..d04e2a0 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/FDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/FDistributionTest.java @@ -16,7 +16,6 @@ */ package org.apache.commons.statistics.distribution; -import org.junit.Assert; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -84,8 +83,8 @@ public class FDistributionTest extends ContinuousDistributionAbstractTest { @Test public void testDfAccessors() { FDistribution dist = (FDistribution) getDistribution(); - Assert.assertEquals(5d, dist.getNumeratorDegreesOfFreedom(), Double.MIN_VALUE); - Assert.assertEquals(6d, dist.getDenominatorDegreesOfFreedom(), Double.MIN_VALUE); + Assertions.assertEquals(5d, dist.getNumeratorDegreesOfFreedom(), Double.MIN_VALUE); + Assertions.assertEquals(6d, dist.getDenominatorDegreesOfFreedom(), Double.MIN_VALUE); } @Test @@ -102,7 +101,7 @@ public class FDistributionTest extends ContinuousDistributionAbstractTest { FDistribution fd = new FDistribution(100000, 100000); double p = fd.cumulativeProbability(.999); double x = fd.inverseCumulativeProbability(p); - Assert.assertEquals(.999, x, 1.0e-5); + Assertions.assertEquals(.999, x, 1.0e-5); } @Test @@ -110,12 +109,12 @@ public class FDistributionTest extends ContinuousDistributionAbstractTest { FDistribution fd = new FDistribution(1, 1); double p = fd.cumulativeProbability(0.975); double x = fd.inverseCumulativeProbability(p); - Assert.assertEquals(0.975, x, 1.0e-5); + Assertions.assertEquals(0.975, x, 1.0e-5); fd = new FDistribution(1, 2); p = fd.cumulativeProbability(0.975); x = fd.inverseCumulativeProbability(p); - Assert.assertEquals(0.975, x, 1.0e-5); + Assertions.assertEquals(0.975, x, 1.0e-5); } @Test @@ -124,16 +123,16 @@ public class FDistributionTest extends ContinuousDistributionAbstractTest { FDistribution dist; dist = new FDistribution(1, 2); - Assert.assertTrue(Double.isNaN(dist.getMean())); - Assert.assertTrue(Double.isNaN(dist.getVariance())); + Assertions.assertTrue(Double.isNaN(dist.getMean())); + Assertions.assertTrue(Double.isNaN(dist.getVariance())); dist = new FDistribution(1, 3); - Assert.assertEquals(3d / (3d - 2d), dist.getMean(), tol); - Assert.assertTrue(Double.isNaN(dist.getVariance())); + Assertions.assertEquals(3d / (3d - 2d), dist.getMean(), tol); + Assertions.assertTrue(Double.isNaN(dist.getVariance())); dist = new FDistribution(1, 5); - Assert.assertEquals(5d / (5d - 2d), dist.getMean(), tol); - Assert.assertEquals((2d * 5d * 5d * 4d) / 9d, dist.getVariance(), tol); + Assertions.assertEquals(5d / (5d - 2d), dist.getMean(), tol); + Assertions.assertEquals((2d * 5d * 5d * 4d) / 9d, dist.getVariance(), tol); } @Test @@ -144,9 +143,9 @@ public class FDistributionTest extends ContinuousDistributionAbstractTest { double prob = 0.01; FDistribution f = new FDistribution(200000, 200000); double result = f.inverseCumulativeProbability(prob); - Assert.assertTrue(result < 1.0); + Assertions.assertTrue(result < 1.0); } catch (AssertionError ex) { - Assert.fail("Failing to calculate inverse cumulative probability"); + Assertions.fail("Failing to calculate inverse cumulative probability"); } } } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/GammaDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/GammaDistributionTest.java index 1597a3e..064e727 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/GammaDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/GammaDistributionTest.java @@ -24,7 +24,6 @@ import java.io.InputStreamReader; import org.apache.commons.numbers.gamma.LanczosApproximation; import org.apache.commons.math3.stat.descriptive.SummaryStatistics; -import org.junit.Assert; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -79,8 +78,8 @@ public class GammaDistributionTest extends ContinuousDistributionAbstractTest { @Test public void testParameterAccessors() { GammaDistribution distribution = (GammaDistribution) getDistribution(); - Assert.assertEquals(4d, distribution.getShape(), 0); - Assert.assertEquals(2d, distribution.getScale(), 0); + Assertions.assertEquals(4d, distribution.getShape(), 0); + Assertions.assertEquals(2d, distribution.getScale(), 0); } @Test @@ -112,13 +111,13 @@ public class GammaDistributionTest extends ContinuousDistributionAbstractTest { private void testProbability(double x, double a, double b, double expected) { GammaDistribution distribution = new GammaDistribution(a, b); double actual = distribution.cumulativeProbability(x); - Assert.assertEquals("probability for " + x, expected, actual, 10e-4); + Assertions.assertEquals(expected, actual, 10e-4, () -> "probability for " + x); } private void testValue(double expected, double a, double b, double p) { GammaDistribution distribution = new GammaDistribution(a, b); double actual = distribution.inverseCumulativeProbability(p); - Assert.assertEquals("critical value for " + p, expected, actual, 10e-4); + Assertions.assertEquals(expected, actual, 10e-4, () -> "critical value for " + p); } @Test @@ -145,7 +144,7 @@ public class GammaDistributionTest extends ContinuousDistributionAbstractTest { private void checkDensity(double alpha, double rate, double[] x, double[] expected) { GammaDistribution d = new GammaDistribution(alpha, 1 / rate); for (int i = 0; i < x.length; i++) { - Assert.assertEquals(expected[i], d.density(x[i]), 1e-5); + Assertions.assertEquals(expected[i], d.density(x[i]), 1e-5); } } @@ -162,12 +161,12 @@ public class GammaDistributionTest extends ContinuousDistributionAbstractTest { GammaDistribution dist; dist = new GammaDistribution(1, 2); - Assert.assertEquals(2, dist.getMean(), tol); - Assert.assertEquals(4, dist.getVariance(), tol); + Assertions.assertEquals(2, dist.getMean(), tol); + Assertions.assertEquals(4, dist.getVariance(), tol); dist = new GammaDistribution(1.1, 4.2); - Assert.assertEquals(1.1d * 4.2d, dist.getMean(), tol); - Assert.assertEquals(1.1d * 4.2d * 4.2d, dist.getVariance(), tol); + Assertions.assertEquals(1.1d * 4.2d, dist.getMean(), tol); + Assertions.assertEquals(1.1d * 4.2d * 4.2d, dist.getVariance(), tol); } public static double logGamma(double x) { @@ -224,8 +223,7 @@ public class GammaDistributionTest extends ContinuousDistributionAbstractTest { final InputStream resourceAsStream; resourceAsStream = this.getClass().getResourceAsStream(resourceName); - Assert.assertNotNull("Could not find resource " + resourceName, - resourceAsStream); + Assertions.assertNotNull(resourceAsStream, () -> "Could not find resource " + resourceName); final BufferedReader in; in = new BufferedReader(new InputStreamReader(resourceAsStream)); @@ -235,8 +233,7 @@ public class GammaDistributionTest extends ContinuousDistributionAbstractTest { continue; } final String[] tokens = line.split(", "); - Assert.assertTrue("expected two floating-point values", - tokens.length == 2); + Assertions.assertTrue(tokens.length == 2, "expected two floating-point values"); final double x = Double.parseDouble(tokens[0]); final String msg = "x = " + x + ", shape = " + shape + ", scale = 1.0"; @@ -248,8 +245,8 @@ public class GammaDistributionTest extends ContinuousDistributionAbstractTest { final double errNew = Math.abs((actualNew - expected) / ulp); if (Double.isNaN(actualOld) || Double.isInfinite(actualOld)) { - Assert.assertFalse(msg, Double.isNaN(actualNew)); - Assert.assertFalse(msg, Double.isInfinite(actualNew)); + Assertions.assertFalse(Double.isNaN(actualNew), msg); + Assertions.assertFalse(Double.isInfinite(actualNew), msg); statNewOF.addValue(errNew); } else { statOld.addValue(errOld); @@ -274,22 +271,22 @@ public class GammaDistributionTest extends ContinuousDistributionAbstractTest { final double oldMin = statOld.getMin(); final double newMin = statNewNoOF.getMin(); - Assert.assertTrue(msg, newMin <= oldMin); + Assertions.assertTrue(newMin <= oldMin, msg); final double oldMax = statOld.getMax(); final double newMax = statNewNoOF.getMax(); - Assert.assertTrue(msg, newMax <= oldMax); + Assertions.assertTrue(newMax <= oldMax, msg); final double oldMean = statOld.getMean(); final double newMean = statNewNoOF.getMean(); - Assert.assertTrue(msg, newMean <= oldMean); + Assertions.assertTrue(newMean <= oldMean, msg); final double oldSd = statOld.getStandardDeviation(); final double newSd = statNewNoOF.getStandardDeviation(); - Assert.assertTrue(msg, newSd <= oldSd); + Assertions.assertTrue(newSd <= oldSd, msg); - Assert.assertTrue(msg, newMean <= meanNoOF); - Assert.assertTrue(msg, newSd <= sdNoOF); + Assertions.assertTrue(newMean <= meanNoOF, msg); + Assertions.assertTrue(newSd <= sdNoOF, msg); } if (statNewOF.getN() != 0) { final double newMean = statNewOF.getMean(); @@ -308,11 +305,11 @@ public class GammaDistributionTest extends ContinuousDistributionAbstractTest { sb.append(newSd); final String msg = sb.toString(); - Assert.assertTrue(msg, newMean <= meanOF); - Assert.assertTrue(msg, newSd <= sdOF); + Assertions.assertTrue(newMean <= meanOF, msg); + Assertions.assertTrue(newSd <= sdOF, msg); } } catch (IOException e) { - Assert.fail(e.getMessage()); + Assertions.fail(e.getMessage()); } finally { in.close(); } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/GeometricDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/GeometricDistributionTest.java index 0eb5512..2820ee4 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/GeometricDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/GeometricDistributionTest.java @@ -16,7 +16,7 @@ */ package org.apache.commons.statistics.distribution; -import org.junit.Assert; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -161,11 +161,11 @@ public class GeometricDistributionTest extends DiscreteDistributionAbstractTest GeometricDistribution dist; dist = new GeometricDistribution(0.5); - Assert.assertEquals((1.0d - 0.5d) / 0.5d, dist.getMean(), tol); - Assert.assertEquals((1.0d - 0.5d) / (0.5d * 0.5d), dist.getVariance(), tol); + Assertions.assertEquals((1.0d - 0.5d) / 0.5d, dist.getMean(), tol); + Assertions.assertEquals((1.0d - 0.5d) / (0.5d * 0.5d), dist.getVariance(), tol); dist = new GeometricDistribution(0.3); - Assert.assertEquals((1.0d - 0.3d) / 0.3d, dist.getMean(), tol); - Assert.assertEquals((1.0d - 0.3d) / (0.3d * 0.3d), dist.getVariance(), tol); + Assertions.assertEquals((1.0d - 0.3d) / 0.3d, dist.getMean(), tol); + Assertions.assertEquals((1.0d - 0.3d) / (0.3d * 0.3d), dist.getVariance(), tol); } } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/GumbelDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/GumbelDistributionTest.java index 613d5aa..f0bcf73 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/GumbelDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/GumbelDistributionTest.java @@ -17,7 +17,7 @@ package org.apache.commons.statistics.distribution; import org.apache.commons.numbers.core.Precision; -import org.junit.Assert; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -28,16 +28,16 @@ public class GumbelDistributionTest extends ContinuousDistributionAbstractTest { @Test public void testParameters() { GumbelDistribution d = makeDistribution(); - Assert.assertEquals(0.5, d.getLocation(), Precision.EPSILON); - Assert.assertEquals(2, d.getScale(), Precision.EPSILON); + Assertions.assertEquals(0.5, d.getLocation(), Precision.EPSILON); + Assertions.assertEquals(2, d.getScale(), Precision.EPSILON); } @Test public void testSupport() { GumbelDistribution d = makeDistribution(); - Assert.assertTrue(Double.isInfinite(d.getSupportLowerBound())); - Assert.assertTrue(Double.isInfinite(d.getSupportUpperBound())); - Assert.assertTrue(d.isSupportConnected()); + Assertions.assertTrue(Double.isInfinite(d.getSupportLowerBound())); + Assertions.assertTrue(Double.isInfinite(d.getSupportUpperBound())); + Assertions.assertTrue(d.isSupportConnected()); } @Override diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/HypergeometricDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/HypergeometricDistributionTest.java index 14e15fe..d65f5da 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/HypergeometricDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/HypergeometricDistributionTest.java @@ -19,7 +19,6 @@ package org.apache.commons.statistics.distribution; import org.apache.commons.numbers.core.Precision; import org.apache.commons.rng.simple.RandomSource; -import org.junit.Assert; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -119,8 +118,8 @@ public class HypergeometricDistributionTest extends DiscreteDistributionAbstract verifyDensities(); verifyCumulativeProbabilities(); verifyInverseCumulativeProbabilities(); - Assert.assertEquals(3, dist.getSupportLowerBound()); - Assert.assertEquals(3, dist.getSupportUpperBound()); + Assertions.assertEquals(3, dist.getSupportLowerBound()); + Assertions.assertEquals(3, dist.getSupportUpperBound()); } /** Verify that if there are no successes, mass is concentrated on 0 */ @@ -137,8 +136,8 @@ public class HypergeometricDistributionTest extends DiscreteDistributionAbstract verifyDensities(); verifyCumulativeProbabilities(); verifyInverseCumulativeProbabilities(); - Assert.assertEquals(0, dist.getSupportLowerBound()); - Assert.assertEquals(0, dist.getSupportUpperBound()); + Assertions.assertEquals(0, dist.getSupportLowerBound()); + Assertions.assertEquals(0, dist.getSupportUpperBound()); } /** Verify that if sampleSize = populationSize, mass is concentrated on numberOfSuccesses */ @@ -155,8 +154,8 @@ public class HypergeometricDistributionTest extends DiscreteDistributionAbstract verifyDensities(); verifyCumulativeProbabilities(); verifyInverseCumulativeProbabilities(); - Assert.assertEquals(3, dist.getSupportLowerBound()); - Assert.assertEquals(3, dist.getSupportUpperBound()); + Assertions.assertEquals(3, dist.getSupportLowerBound()); + Assertions.assertEquals(3, dist.getSupportUpperBound()); } @Test @@ -183,9 +182,9 @@ public class HypergeometricDistributionTest extends DiscreteDistributionAbstract @Test public void testAccessors() { HypergeometricDistribution dist = new HypergeometricDistribution(5, 3, 4); - Assert.assertEquals(5, dist.getPopulationSize()); - Assert.assertEquals(3, dist.getNumberOfSuccesses()); - Assert.assertEquals(4, dist.getSampleSize()); + Assertions.assertEquals(5, dist.getPopulationSize()); + Assertions.assertEquals(3, dist.getNumberOfSuccesses()); + Assertions.assertEquals(4, dist.getSampleSize()); } @Test @@ -270,12 +269,12 @@ public class HypergeometricDistributionTest extends DiscreteDistributionAbstract HypergeometricDistribution dist; dist = new HypergeometricDistribution(1500, 40, 100); - Assert.assertEquals(40d * 100d / 1500d, dist.getMean(), tol); - Assert.assertEquals((100d * 40d * (1500d - 100d) * (1500d - 40d)) / ((1500d * 1500d * 1499d)), dist.getVariance(), tol); + Assertions.assertEquals(40d * 100d / 1500d, dist.getMean(), tol); + Assertions.assertEquals((100d * 40d * (1500d - 100d) * (1500d - 40d)) / ((1500d * 1500d * 1499d)), dist.getVariance(), tol); dist = new HypergeometricDistribution(3000, 55, 200); - Assert.assertEquals(55d * 200d / 3000d, dist.getMean(), tol); - Assert.assertEquals((200d * 55d * (3000d - 200d) * (3000d - 55d)) / ((3000d * 3000d * 2999d)), dist.getVariance(), tol); + Assertions.assertEquals(55d * 200d / 3000d, dist.getMean(), tol); + Assertions.assertEquals((200d * 55d * (3000d - 200d) * (3000d - 55d)) / ((3000d * 3000d * 2999d)), dist.getVariance(), tol); } @Test @@ -287,12 +286,12 @@ public class HypergeometricDistributionTest extends DiscreteDistributionAbstract final int k = 0; final HypergeometricDistribution dist = new HypergeometricDistribution(N, m, n); - Assert.assertTrue(Precision.compareTo(1.0, dist.upperCumulativeProbability(k), 1) == 0); - Assert.assertTrue(Precision.compareTo(dist.cumulativeProbability(k), 0.0, 1) > 0); + Assertions.assertTrue(Precision.compareTo(1.0, dist.upperCumulativeProbability(k), 1) == 0); + Assertions.assertTrue(Precision.compareTo(dist.cumulativeProbability(k), 0.0, 1) > 0); // another way to calculate the upper cumulative probability double upper = 1.0 - dist.cumulativeProbability(k) + dist.probability(k); - Assert.assertTrue(Precision.compareTo(1.0, upper, 1) == 0); + Assertions.assertTrue(Precision.compareTo(1.0, upper, 1) == 0); } @Test @@ -305,7 +304,7 @@ public class HypergeometricDistributionTest extends DiscreteDistributionAbstract for (int i = 1; i <= n; i++) { final double p = dist.probability(i); - Assert.assertEquals("p=" + p, 0, p, 0d); + Assertions.assertEquals(0, p, 0d, () -> "p=" + p); } } @@ -317,7 +316,7 @@ public class HypergeometricDistributionTest extends DiscreteDistributionAbstract for (int s = 0; s <= n; s++) { final HypergeometricDistribution dist = new HypergeometricDistribution(n, m, s); final double p = dist.probability(s); - Assert.assertEquals("p=" + p, 1, p, 0d); + Assertions.assertEquals(1, p, 0d, () -> "p=" + p); } } @@ -331,8 +330,8 @@ public class HypergeometricDistributionTest extends DiscreteDistributionAbstract for (int i = 0; i < 100; i++) { final int sample = dist.sample(); - Assert.assertTrue("sample=" + sample, 0 <= sample); - Assert.assertTrue("sample=" + sample, sample <= n); + Assertions.assertTrue(0 <= sample, () -> "sample=" + sample); + Assertions.assertTrue(sample <= n, () -> "sample=" + sample); } } } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LaplaceDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LaplaceDistributionTest.java index 8b21beb..827dfa5 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LaplaceDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LaplaceDistributionTest.java @@ -17,7 +17,7 @@ package org.apache.commons.statistics.distribution; import org.apache.commons.numbers.core.Precision; -import org.junit.Assert; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -28,16 +28,16 @@ public class LaplaceDistributionTest extends ContinuousDistributionAbstractTest @Test public void testParameters() { LaplaceDistribution d = makeDistribution(); - Assert.assertEquals(0, d.getLocation(), Precision.EPSILON); - Assert.assertEquals(1, d.getScale(), Precision.EPSILON); + Assertions.assertEquals(0, d.getLocation(), Precision.EPSILON); + Assertions.assertEquals(1, d.getScale(), Precision.EPSILON); } @Test public void testSupport() { LaplaceDistribution d = makeDistribution(); - Assert.assertTrue(Double.isInfinite(d.getSupportLowerBound())); - Assert.assertTrue(Double.isInfinite(d.getSupportUpperBound())); - Assert.assertTrue(d.isSupportConnected()); + Assertions.assertTrue(Double.isInfinite(d.getSupportLowerBound())); + Assertions.assertTrue(Double.isInfinite(d.getSupportUpperBound())); + Assertions.assertTrue(d.isSupportConnected()); } @Override diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LevyDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LevyDistributionTest.java index d86971e..fd10305 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LevyDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LevyDistributionTest.java @@ -17,7 +17,7 @@ package org.apache.commons.statistics.distribution; import org.apache.commons.numbers.core.Precision; -import org.junit.Assert; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; public class LevyDistributionTest extends ContinuousDistributionAbstractTest { @@ -25,16 +25,16 @@ public class LevyDistributionTest extends ContinuousDistributionAbstractTest { @Test public void testParameters() { LevyDistribution d = makeDistribution(); - Assert.assertEquals(1.2, d.getLocation(), Precision.EPSILON); - Assert.assertEquals(0.4, d.getScale(), Precision.EPSILON); + Assertions.assertEquals(1.2, d.getLocation(), Precision.EPSILON); + Assertions.assertEquals(0.4, d.getScale(), Precision.EPSILON); } @Test public void testSupport() { LevyDistribution d = makeDistribution(); - Assert.assertEquals(d.getLocation(), d.getSupportLowerBound(), Precision.EPSILON); - Assert.assertTrue(Double.isInfinite(d.getSupportUpperBound())); - Assert.assertTrue(d.isSupportConnected()); + Assertions.assertEquals(d.getLocation(), d.getSupportLowerBound(), Precision.EPSILON); + Assertions.assertTrue(Double.isInfinite(d.getSupportUpperBound())); + Assertions.assertTrue(d.isSupportConnected()); } @Override diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LogNormalDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LogNormalDistributionTest.java index b73b6c8..382649b 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LogNormalDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LogNormalDistributionTest.java @@ -17,7 +17,6 @@ package org.apache.commons.statistics.distribution; -import org.junit.Assert; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -163,13 +162,13 @@ public class LogNormalDistributionTest extends ContinuousDistributionAbstractTes @Test public void testGetScale() { LogNormalDistribution distribution = (LogNormalDistribution)getDistribution(); - Assert.assertEquals(2.1, distribution.getScale(), 0); + Assertions.assertEquals(2.1, distribution.getScale(), 0); } @Test public void testGetShape() { LogNormalDistribution distribution = (LogNormalDistribution)getDistribution(); - Assert.assertEquals(1.4, distribution.getShape(), 0); + Assertions.assertEquals(1.4, distribution.getShape(), 0); } @Test @@ -196,7 +195,7 @@ public class LogNormalDistributionTest extends ContinuousDistributionAbstractTes double[] expected) { LogNormalDistribution d = new LogNormalDistribution(scale, shape); for (int i = 0; i < x.length; i++) { - Assert.assertEquals(expected[i], d.density(x[i]), 1e-9); + Assertions.assertEquals(expected[i], d.density(x[i]), 1e-9); } } @@ -210,16 +209,16 @@ public class LogNormalDistributionTest extends ContinuousDistributionAbstractTes for (int i = 0; i < 1e5; i++) { // make sure no convergence exception double upperTail = d.cumulativeProbability(i); if (i <= 72) { // make sure not top-coded - Assert.assertTrue(upperTail < 1.0d); + Assertions.assertTrue(upperTail < 1.0d); } else { // make sure top coding not reversed - Assert.assertTrue(upperTail > 0.99999); + Assertions.assertTrue(upperTail > 0.99999); } } - Assert.assertEquals(1, d.cumulativeProbability(Double.MAX_VALUE), 0); - Assert.assertEquals(0, d.cumulativeProbability(-Double.MAX_VALUE), 0); - Assert.assertEquals(1, d.cumulativeProbability(Double.POSITIVE_INFINITY), 0); - Assert.assertEquals(0, d.cumulativeProbability(Double.NEGATIVE_INFINITY), 0); + Assertions.assertEquals(1, d.cumulativeProbability(Double.MAX_VALUE), 0); + Assertions.assertEquals(0, d.cumulativeProbability(-Double.MAX_VALUE), 0); + Assertions.assertEquals(1, d.cumulativeProbability(Double.POSITIVE_INFINITY), 0); + Assertions.assertEquals(0, d.cumulativeProbability(Double.NEGATIVE_INFINITY), 0); } @Test @@ -228,22 +227,22 @@ public class LogNormalDistributionTest extends ContinuousDistributionAbstractTes LogNormalDistribution dist; dist = new LogNormalDistribution(0, 1); - Assert.assertEquals(1.6487212707001282, dist.getMean(), tol); - Assert.assertEquals(4.670774270471604, dist.getVariance(), tol); + Assertions.assertEquals(1.6487212707001282, dist.getMean(), tol); + Assertions.assertEquals(4.670774270471604, dist.getVariance(), tol); dist = new LogNormalDistribution(2.2, 1.4); - Assert.assertEquals(24.046753552064498, dist.getMean(), tol); - Assert.assertEquals(3526.913651880464, dist.getVariance(), tol); + Assertions.assertEquals(24.046753552064498, dist.getMean(), tol); + Assertions.assertEquals(3526.913651880464, dist.getVariance(), tol); dist = new LogNormalDistribution(-2000.9, 10.4); - Assert.assertEquals(0.0, dist.getMean(), tol); - Assert.assertEquals(0.0, dist.getVariance(), tol); + Assertions.assertEquals(0.0, dist.getMean(), tol); + Assertions.assertEquals(0.0, dist.getVariance(), tol); } @Test public void testTinyVariance() { LogNormalDistribution dist = new LogNormalDistribution(0, 1e-9); double t = dist.getVariance(); - Assert.assertEquals(1e-18, t, 1e-20); + Assertions.assertEquals(1e-18, t, 1e-20); } } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LogisticsDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LogisticsDistributionTest.java index a42b804..1aa6d0e 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LogisticsDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LogisticsDistributionTest.java @@ -17,7 +17,7 @@ package org.apache.commons.statistics.distribution; import org.apache.commons.numbers.core.Precision; -import org.junit.Assert; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -28,16 +28,16 @@ public class LogisticsDistributionTest extends ContinuousDistributionAbstractTes @Test public void testParameters() { LogisticDistribution d = makeDistribution(); - Assert.assertEquals(2, d.getLocation(), Precision.EPSILON); - Assert.assertEquals(5, d.getScale(), Precision.EPSILON); + Assertions.assertEquals(2, d.getLocation(), Precision.EPSILON); + Assertions.assertEquals(5, d.getScale(), Precision.EPSILON); } @Test public void testSupport() { LogisticDistribution d = makeDistribution(); - Assert.assertTrue(Double.isInfinite(d.getSupportLowerBound())); - Assert.assertTrue(Double.isInfinite(d.getSupportUpperBound())); - Assert.assertTrue(d.isSupportConnected()); + Assertions.assertTrue(Double.isInfinite(d.getSupportLowerBound())); + Assertions.assertTrue(Double.isInfinite(d.getSupportUpperBound())); + Assertions.assertTrue(d.isSupportConnected()); } @Override diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/NakagamiDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/NakagamiDistributionTest.java index fb74471..c7d010a 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/NakagamiDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/NakagamiDistributionTest.java @@ -17,7 +17,7 @@ package org.apache.commons.statistics.distribution; import org.apache.commons.numbers.core.Precision; -import org.junit.Assert; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -28,16 +28,16 @@ public class NakagamiDistributionTest extends ContinuousDistributionAbstractTest @Test public void testParameters() { NakagamiDistribution d = makeDistribution(); - Assert.assertEquals(0.5, d.getShape(), Precision.EPSILON); - Assert.assertEquals(1, d.getScale(), Precision.EPSILON); + Assertions.assertEquals(0.5, d.getShape(), Precision.EPSILON); + Assertions.assertEquals(1, d.getScale(), Precision.EPSILON); } @Test public void testSupport() { NakagamiDistribution d = makeDistribution(); - Assert.assertEquals(d.getSupportLowerBound(), 0, Precision.EPSILON); - Assert.assertTrue(Double.isInfinite(d.getSupportUpperBound())); - Assert.assertTrue(d.isSupportConnected()); + Assertions.assertEquals(d.getSupportLowerBound(), 0, Precision.EPSILON); + Assertions.assertTrue(Double.isInfinite(d.getSupportUpperBound())); + Assertions.assertTrue(d.isSupportConnected()); } @Override diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/NormalDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/NormalDistributionTest.java index 50f3fbc..b146c21 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/NormalDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/NormalDistributionTest.java @@ -17,7 +17,6 @@ package org.apache.commons.statistics.distribution; -import org.junit.Assert; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -120,19 +119,19 @@ public class NormalDistributionTest extends ContinuousDistributionAbstractTest { double expected = 7.61985e-24; double v = dist.cumulativeProbability(x); double tol = 1e-5; - Assert.assertEquals(1, v / expected, 1e-5); + Assertions.assertEquals(1, v / expected, 1e-5); } @Test public void testGetMean() { NormalDistribution distribution = (NormalDistribution) getDistribution(); - Assert.assertEquals(2.1, distribution.getMean(), 0); + Assertions.assertEquals(2.1, distribution.getMean(), 0); } @Test public void testGetStandardDeviation() { NormalDistribution distribution = (NormalDistribution) getDistribution(); - Assert.assertEquals(1.4, distribution.getStandardDeviation(), 0); + Assertions.assertEquals(1.4, distribution.getStandardDeviation(), 0); } @Test @@ -152,7 +151,7 @@ public class NormalDistributionTest extends ContinuousDistributionAbstractTest { private void checkDensity(double mean, double sd, double[] x, double[] expected) { NormalDistribution d = new NormalDistribution(mean, sd); for (int i = 0; i < x.length; i++) { - Assert.assertEquals(expected[i], d.density(x[i]), 1e-9); + Assertions.assertEquals(expected[i], d.density(x[i]), 1e-9); } } @@ -169,31 +168,31 @@ public class NormalDistributionTest extends ContinuousDistributionAbstractTest { if (i < 9) { // make sure not top-coded // For i = 10, due to bad tail precision in erf (MATH-364), 1 is returned // TODO: once MATH-364 is resolved, replace 9 with 30 - Assert.assertTrue(lowerTail > 0.0d); - Assert.assertTrue(upperTail < 1.0d); + Assertions.assertTrue(lowerTail > 0.0d); + Assertions.assertTrue(upperTail < 1.0d); } else { // make sure top coding not reversed - Assert.assertTrue(lowerTail < 0.00001); - Assert.assertTrue(upperTail > 0.99999); + Assertions.assertTrue(lowerTail < 0.00001); + Assertions.assertTrue(upperTail > 0.99999); } } - Assert.assertEquals(1, distribution.cumulativeProbability(Double.MAX_VALUE), 0); - Assert.assertEquals(0, distribution.cumulativeProbability(-Double.MAX_VALUE), 0); - Assert.assertEquals(1, distribution.cumulativeProbability(Double.POSITIVE_INFINITY), 0); - Assert.assertEquals(0, distribution.cumulativeProbability(Double.NEGATIVE_INFINITY), 0); + Assertions.assertEquals(1, distribution.cumulativeProbability(Double.MAX_VALUE), 0); + Assertions.assertEquals(0, distribution.cumulativeProbability(-Double.MAX_VALUE), 0); + Assertions.assertEquals(1, distribution.cumulativeProbability(Double.POSITIVE_INFINITY), 0); + Assertions.assertEquals(0, distribution.cumulativeProbability(Double.NEGATIVE_INFINITY), 0); } @Test public void testMath280() { NormalDistribution normal = new NormalDistribution(0, 1); double result = normal.inverseCumulativeProbability(0.9986501019683698); - Assert.assertEquals(3.0, result, DEFAULT_TOLERANCE); + Assertions.assertEquals(3.0, result, DEFAULT_TOLERANCE); result = normal.inverseCumulativeProbability(0.841344746068543); - Assert.assertEquals(1.0, result, DEFAULT_TOLERANCE); + Assertions.assertEquals(1.0, result, DEFAULT_TOLERANCE); result = normal.inverseCumulativeProbability(0.9999683287581673); - Assert.assertEquals(4.0, result, DEFAULT_TOLERANCE); + Assertions.assertEquals(4.0, result, DEFAULT_TOLERANCE); result = normal.inverseCumulativeProbability(0.9772498680518209); - Assert.assertEquals(2.0, result, DEFAULT_TOLERANCE); + Assertions.assertEquals(2.0, result, DEFAULT_TOLERANCE); } @Test @@ -202,15 +201,15 @@ public class NormalDistributionTest extends ContinuousDistributionAbstractTest { NormalDistribution dist; dist = new NormalDistribution(0, 1); - Assert.assertEquals(0, dist.getMean(), tol); - Assert.assertEquals(1, dist.getVariance(), tol); + Assertions.assertEquals(0, dist.getMean(), tol); + Assertions.assertEquals(1, dist.getVariance(), tol); dist = new NormalDistribution(2.2, 1.4); - Assert.assertEquals(2.2, dist.getMean(), tol); - Assert.assertEquals(1.4 * 1.4, dist.getVariance(), tol); + Assertions.assertEquals(2.2, dist.getMean(), tol); + Assertions.assertEquals(1.4 * 1.4, dist.getVariance(), tol); dist = new NormalDistribution(-2000.9, 10.4); - Assert.assertEquals(-2000.9, dist.getMean(), tol); - Assert.assertEquals(10.4 * 10.4, dist.getVariance(), tol); + Assertions.assertEquals(-2000.9, dist.getMean(), tol); + Assertions.assertEquals(10.4 * 10.4, dist.getVariance(), tol); } } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ParetoDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ParetoDistributionTest.java index 3b1bcdd..b1b2700 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ParetoDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ParetoDistributionTest.java @@ -17,7 +17,6 @@ package org.apache.commons.statistics.distribution; -import org.junit.Assert; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -134,13 +133,13 @@ public class ParetoDistributionTest extends ContinuousDistributionAbstractTest { @Test public void testGetScale() { ParetoDistribution distribution = (ParetoDistribution)getDistribution(); - Assert.assertEquals(2.1, distribution.getScale(), 0); + Assertions.assertEquals(2.1, distribution.getScale(), 0); } @Test public void testGetShape() { ParetoDistribution distribution = (ParetoDistribution)getDistribution(); - Assert.assertEquals(1.4, distribution.getShape(), 0); + Assertions.assertEquals(1.4, distribution.getShape(), 0); } @Test @@ -161,7 +160,7 @@ public class ParetoDistributionTest extends ContinuousDistributionAbstractTest { double[] expected) { ParetoDistribution d = new ParetoDistribution(scale, shape); for (int i = 0; i < x.length; i++) { - Assert.assertEquals(expected[i], d.density(x[i]), 1e-9); + Assertions.assertEquals(expected[i], d.density(x[i]), 1e-9); } } @@ -174,16 +173,16 @@ public class ParetoDistributionTest extends ContinuousDistributionAbstractTest { for (int i = 0; i < 1e5; i++) { // make sure no convergence exception double upperTail = d.cumulativeProbability(i); if (i <= 1000) { // make sure not top-coded - Assert.assertTrue(upperTail < 1.0d); + Assertions.assertTrue(upperTail < 1.0d); } else { // make sure top coding not reversed - Assert.assertTrue(upperTail > 0.999); + Assertions.assertTrue(upperTail > 0.999); } } - Assert.assertEquals(1, d.cumulativeProbability(Double.MAX_VALUE), 0); - Assert.assertEquals(0, d.cumulativeProbability(-Double.MAX_VALUE), 0); - Assert.assertEquals(1, d.cumulativeProbability(Double.POSITIVE_INFINITY), 0); - Assert.assertEquals(0, d.cumulativeProbability(Double.NEGATIVE_INFINITY), 0); + Assertions.assertEquals(1, d.cumulativeProbability(Double.MAX_VALUE), 0); + Assertions.assertEquals(0, d.cumulativeProbability(-Double.MAX_VALUE), 0); + Assertions.assertEquals(1, d.cumulativeProbability(Double.POSITIVE_INFINITY), 0); + Assertions.assertEquals(0, d.cumulativeProbability(Double.NEGATIVE_INFINITY), 0); } @Test @@ -192,11 +191,11 @@ public class ParetoDistributionTest extends ContinuousDistributionAbstractTest { ParetoDistribution dist; dist = new ParetoDistribution(1, 1); - Assert.assertEquals(Double.POSITIVE_INFINITY, dist.getMean(), tol); - Assert.assertEquals(Double.POSITIVE_INFINITY, dist.getVariance(), tol); + Assertions.assertEquals(Double.POSITIVE_INFINITY, dist.getMean(), tol); + Assertions.assertEquals(Double.POSITIVE_INFINITY, dist.getVariance(), tol); dist = new ParetoDistribution(2.2, 2.4); - Assert.assertEquals(3.771428571428, dist.getMean(), tol); - Assert.assertEquals(14.816326530, dist.getVariance(), tol); + Assertions.assertEquals(3.771428571428, dist.getMean(), tol); + Assertions.assertEquals(14.816326530, dist.getVariance(), tol); } } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/PascalDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/PascalDistributionTest.java index 1ed7511..1dc4107 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/PascalDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/PascalDistributionTest.java @@ -16,7 +16,7 @@ */ package org.apache.commons.statistics.distribution; -import org.junit.Assert; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -123,11 +123,11 @@ public class PascalDistributionTest extends DiscreteDistributionAbstractTest { PascalDistribution dist; dist = new PascalDistribution(10, 0.5); - Assert.assertEquals((10d * 0.5d) / 0.5d, dist.getMean(), tol); - Assert.assertEquals((10d * 0.5d) / (0.5d * 0.5d), dist.getVariance(), tol); + Assertions.assertEquals((10d * 0.5d) / 0.5d, dist.getMean(), tol); + Assertions.assertEquals((10d * 0.5d) / (0.5d * 0.5d), dist.getVariance(), tol); dist = new PascalDistribution(25, 0.7); - Assert.assertEquals((25d * 0.3d) / 0.7d, dist.getMean(), tol); - Assert.assertEquals((25d * 0.3d) / (0.7d * 0.7d), dist.getVariance(), tol); + Assertions.assertEquals((25d * 0.3d) / 0.7d, dist.getMean(), tol); + Assertions.assertEquals((25d * 0.3d) / (0.7d * 0.7d), dist.getVariance(), tol); } } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/PoissonDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/PoissonDistributionTest.java index 0e2f693..64dfac4 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/PoissonDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/PoissonDistributionTest.java @@ -16,7 +16,6 @@ */ package org.apache.commons.statistics.distribution; -import org.junit.Assert; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -127,12 +126,12 @@ public class PoissonDistributionTest extends DiscreteDistributionAbstractTest { PoissonDistribution dist = new PoissonDistribution(100); double result = dist.normalApproximateProbability(110) - dist.normalApproximateProbability(89); - Assert.assertEquals(0.706281887248, result, 1e-10); + Assertions.assertEquals(0.706281887248, result, 1e-10); dist = new PoissonDistribution(10000); result = dist.normalApproximateProbability(10200) - dist.normalApproximateProbability(9899); - Assert.assertEquals(0.820070051552, result, 1E-10); + Assertions.assertEquals(0.820070051552, result, 1E-10); } /** @@ -141,8 +140,8 @@ public class PoissonDistributionTest extends DiscreteDistributionAbstractTest { @Test public void testDegenerateInverseCumulativeProbability() { PoissonDistribution dist = new PoissonDistribution(DEFAULT_TEST_POISSON_PARAMETER); - Assert.assertEquals(Integer.MAX_VALUE, dist.inverseCumulativeProbability(1.0d)); - Assert.assertEquals(0, dist.inverseCumulativeProbability(0d)); + Assertions.assertEquals(Integer.MAX_VALUE, dist.inverseCumulativeProbability(1.0d)); + Assertions.assertEquals(0, dist.inverseCumulativeProbability(0d)); } @Test @@ -153,7 +152,7 @@ public class PoissonDistributionTest extends DiscreteDistributionAbstractTest { @Test public void testMean() { PoissonDistribution dist = new PoissonDistribution(10.0); - Assert.assertEquals(10.0, dist.getMean(), 0.0); + Assertions.assertEquals(10.0, dist.getMean(), 0.0); } @Test @@ -169,14 +168,12 @@ public class PoissonDistributionTest extends DiscreteDistributionAbstractTest { while (x >= 0) { try { p = dist.cumulativeProbability((int) x); - Assert.assertFalse("NaN cumulative probability returned for mean = " + - mean + " x = " + x, Double.isNaN(p)); + Assertions.assertFalse(Double.isNaN(p), "NaN cumulative probability"); if (x > mean - 2 * sigma) { - Assert.assertTrue("Zero cum probaility returned for mean = " + - mean + " x = " + x, p > 0); + Assertions.assertTrue(p > 0, "Zero cumulative probaility"); } } catch (AssertionError ex) { - Assert.fail("mean of " + mean + " and x of " + x + " caused " + ex.getMessage()); + Assertions.fail("mean of " + mean + " and x of " + x + " caused " + ex.getMessage()); } x -= dx; } @@ -201,11 +198,11 @@ public class PoissonDistributionTest extends DiscreteDistributionAbstractTest { } private void checkProbability(PoissonDistribution dist, int x) { - double p = dist.cumulativeProbability(x); - Assert.assertFalse("NaN cumulative probability returned for mean = " + - dist.getMean() + " x = " + x, Double.isNaN(p)); - Assert.assertTrue("Zero cum probability returned for mean = " + - dist.getMean() + " x = " + x, p > 0); + final double p = dist.cumulativeProbability(x); + Assertions.assertFalse(Double.isNaN(p), () -> "NaN cumulative probability returned for mean = " + + dist.getMean() + " x = " + x); + Assertions.assertTrue(p > 0, () -> "Zero cum probability returned for mean = " + + dist.getMean() + " x = " + x); } @Test @@ -219,10 +216,10 @@ public class PoissonDistributionTest extends DiscreteDistributionAbstractTest { try { int ret = dist.inverseCumulativeProbability(p); // Verify that returned value satisties definition - Assert.assertTrue(p <= dist.cumulativeProbability(ret)); - Assert.assertTrue(p > dist.cumulativeProbability(ret - 1)); + Assertions.assertTrue(p <= dist.cumulativeProbability(ret)); + Assertions.assertTrue(p > dist.cumulativeProbability(ret - 1)); } catch (AssertionError ex) { - Assert.fail("mean of " + mean + " and p of " + p + " caused " + ex.getMessage()); + Assertions.fail("mean of " + mean + " and p of " + p + " caused " + ex.getMessage()); } p += dp; } @@ -236,11 +233,11 @@ public class PoissonDistributionTest extends DiscreteDistributionAbstractTest { PoissonDistribution dist; dist = new PoissonDistribution(1); - Assert.assertEquals(1, dist.getMean(), tol); - Assert.assertEquals(1, dist.getVariance(), tol); + Assertions.assertEquals(1, dist.getMean(), tol); + Assertions.assertEquals(1, dist.getVariance(), tol); dist = new PoissonDistribution(11.23); - Assert.assertEquals(11.23, dist.getMean(), tol); - Assert.assertEquals(11.23, dist.getVariance(), tol); + Assertions.assertEquals(11.23, dist.getMean(), tol); + Assertions.assertEquals(11.23, dist.getVariance(), tol); } } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/TDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/TDistributionTest.java index 26089e9..fc52cf6 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/TDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/TDistributionTest.java @@ -16,7 +16,6 @@ */ package org.apache.commons.statistics.distribution; -import org.junit.Assert; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -107,9 +106,9 @@ public class TDistributionTest extends ContinuousDistributionAbstractTest { TDistribution dist; for (int i = 1; i < 11; i++) { dist = new TDistribution(i * 5); - Assert.assertEquals(1, + Assertions.assertEquals(1, dist.cumulativeProbability(Double.POSITIVE_INFINITY), Double.MIN_VALUE); - Assert.assertEquals(0, + Assertions.assertEquals(0, dist.cumulativeProbability(Double.NEGATIVE_INFINITY), Double.MIN_VALUE); } } @@ -117,7 +116,7 @@ public class TDistributionTest extends ContinuousDistributionAbstractTest { @Test public void testDfAccessors() { TDistribution dist = (TDistribution) getDistribution(); - Assert.assertEquals(5d, dist.getDegreesOfFreedom(), Double.MIN_VALUE); + Assertions.assertEquals(5d, dist.getDegreesOfFreedom(), Double.MIN_VALUE); } @Test @@ -131,16 +130,16 @@ public class TDistributionTest extends ContinuousDistributionAbstractTest { TDistribution dist; dist = new TDistribution(1); - Assert.assertTrue(Double.isNaN(dist.getMean())); - Assert.assertTrue(Double.isNaN(dist.getVariance())); + Assertions.assertTrue(Double.isNaN(dist.getMean())); + Assertions.assertTrue(Double.isNaN(dist.getVariance())); dist = new TDistribution(1.5); - Assert.assertEquals(0, dist.getMean(), tol); - Assert.assertTrue(Double.isInfinite(dist.getVariance())); + Assertions.assertEquals(0, dist.getMean(), tol); + Assertions.assertTrue(Double.isInfinite(dist.getVariance())); dist = new TDistribution(5); - Assert.assertEquals(0, dist.getMean(), tol); - Assert.assertEquals(5d / (5d - 2d), dist.getVariance(), tol); + Assertions.assertEquals(0, dist.getMean(), tol); + Assertions.assertEquals(5d / (5d - 2d), dist.getVariance(), tol); } /* diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/TestUtils.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/TestUtils.java index c750df4..2e6dde9 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/TestUtils.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/TestUtils.java @@ -20,7 +20,7 @@ package org.apache.commons.statistics.distribution; import java.text.DecimalFormat; import org.apache.commons.math3.stat.inference.ChiSquareTest; import org.apache.commons.numbers.core.Precision; -import org.junit.Assert; +import org.junit.jupiter.api.Assertions; /** * Test utilities. @@ -38,7 +38,7 @@ public final class TestUtils { public static void assertEquals(double expected, double actual, double delta) { - Assert.assertEquals(null, expected, actual, delta); + Assertions.assertEquals(expected, actual, delta); } /** @@ -51,10 +51,9 @@ public final class TestUtils { double delta) { // check for NaN if (Double.isNaN(expected)) { - Assert.assertTrue("" + actual + " is not NaN.", - Double.isNaN(actual)); + Assertions.assertTrue(Double.isNaN(actual), () -> actual + " is not NaN."); } else { - Assert.assertEquals(msg, expected, actual, delta); + Assertions.assertEquals(expected, actual, delta, msg); } } @@ -97,16 +96,16 @@ public final class TestUtils { double actual, double relativeError) { if (Double.isNaN(expected)) { - Assert.assertTrue(msg, Double.isNaN(actual)); + Assertions.assertTrue(Double.isNaN(actual), msg); } else if (Double.isNaN(actual)) { - Assert.assertTrue(msg, Double.isNaN(expected)); + Assertions.assertTrue(Double.isNaN(expected), msg); } else if (Double.isInfinite(actual) || Double.isInfinite(expected)) { - Assert.assertEquals(expected, actual, relativeError); + Assertions.assertEquals(expected, actual, relativeError); } else if (expected == 0.0) { - Assert.assertEquals(msg, actual, expected, relativeError); + Assertions.assertEquals(actual, expected, relativeError, msg); } else { double absError = Math.abs(expected) * relativeError; - Assert.assertEquals(msg, expected, actual, absError); + Assertions.assertEquals(expected, actual, absError, msg); } } @@ -122,7 +121,7 @@ public final class TestUtils { out.append(expected.length); out.append(" observed length = "); out.append(observed.length); - Assert.fail(out.toString()); + Assertions.fail(out.toString()); } boolean failure = false; for (int i = 0; i < expected.length; i++) { @@ -138,7 +137,7 @@ public final class TestUtils { } } if (failure) { - Assert.fail(out.toString()); + Assertions.fail(out.toString()); } } @@ -179,7 +178,7 @@ public final class TestUtils { msgBuffer.append("This test can fail randomly due to sampling error with probability "); msgBuffer.append(alpha); msgBuffer.append("."); - Assert.fail(msgBuffer.toString()); + Assertions.fail(msgBuffer.toString()); } } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/TriangularDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/TriangularDistributionTest.java index f52b2a3..2da110b 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/TriangularDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/TriangularDistributionTest.java @@ -17,7 +17,6 @@ package org.apache.commons.statistics.distribution; -import org.junit.Assert; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -137,14 +136,14 @@ public class TriangularDistributionTest extends ContinuousDistributionAbstractTe @Test public void testGetLowerBound() { TriangularDistribution distribution = makeDistribution(); - Assert.assertEquals(-3.0, distribution.getSupportLowerBound(), 0); + Assertions.assertEquals(-3.0, distribution.getSupportLowerBound(), 0); } /** Test upper bound getter. */ @Test public void testGetUpperBound() { TriangularDistribution distribution = makeDistribution(); - Assert.assertEquals(12.0, distribution.getSupportUpperBound(), 0); + Assertions.assertEquals(12.0, distribution.getSupportUpperBound(), 0); } /** Test pre-condition for equal lower/upper limit. */ @@ -177,15 +176,15 @@ public class TriangularDistributionTest extends ContinuousDistributionAbstractTe TriangularDistribution dist; dist = new TriangularDistribution(0, 0.5, 1.0); - Assert.assertEquals(0.5, dist.getMean(), 0); - Assert.assertEquals(1 / 24.0, dist.getVariance(), 0); + Assertions.assertEquals(0.5, dist.getMean(), 0); + Assertions.assertEquals(1 / 24.0, dist.getVariance(), 0); dist = new TriangularDistribution(0, 1, 1); - Assert.assertEquals(2 / 3.0, dist.getMean(), 0); - Assert.assertEquals(1 / 18.0, dist.getVariance(), 0); + Assertions.assertEquals(2 / 3.0, dist.getMean(), 0); + Assertions.assertEquals(1 / 18.0, dist.getVariance(), 0); dist = new TriangularDistribution(-3, 2, 12); - Assert.assertEquals(3 + (2 / 3.0), dist.getMean(), 0); - Assert.assertEquals(175 / 18.0, dist.getVariance(), 0); + Assertions.assertEquals(3 + (2 / 3.0), dist.getMean(), 0); + Assertions.assertEquals(175 / 18.0, dist.getVariance(), 0); } } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/UniformContinuousDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/UniformContinuousDistributionTest.java index 68d347b..48ff67f 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/UniformContinuousDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/UniformContinuousDistributionTest.java @@ -17,7 +17,6 @@ package org.apache.commons.statistics.distribution; -import org.junit.Assert; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -71,14 +70,14 @@ public class UniformContinuousDistributionTest extends ContinuousDistributionAbs @Test public void testGetLowerBound() { UniformContinuousDistribution distribution = makeDistribution(); - Assert.assertEquals(-0.5, distribution.getSupportLowerBound(), 0); + Assertions.assertEquals(-0.5, distribution.getSupportLowerBound(), 0); } /** Test upper bound getter. */ @Test public void testGetUpperBound() { UniformContinuousDistribution distribution = makeDistribution(); - Assert.assertEquals(1.25, distribution.getSupportUpperBound(), 0); + Assertions.assertEquals(1.25, distribution.getSupportUpperBound(), 0); } /** Test pre-condition for equal lower/upper bound. */ @@ -99,16 +98,16 @@ public class UniformContinuousDistributionTest extends ContinuousDistributionAbs UniformContinuousDistribution dist; dist = new UniformContinuousDistribution(0, 1); - Assert.assertEquals(0.5, dist.getMean(), 0); - Assert.assertEquals(1 / 12.0, dist.getVariance(), 0); + Assertions.assertEquals(0.5, dist.getMean(), 0); + Assertions.assertEquals(1 / 12.0, dist.getVariance(), 0); dist = new UniformContinuousDistribution(-1.5, 0.6); - Assert.assertEquals(-0.45, dist.getMean(), 0); - Assert.assertEquals(0.3675, dist.getVariance(), 0); + Assertions.assertEquals(-0.45, dist.getMean(), 0); + Assertions.assertEquals(0.3675, dist.getVariance(), 0); dist = new UniformContinuousDistribution(-0.5, 1.25); - Assert.assertEquals(0.375, dist.getMean(), 0); - Assert.assertEquals(0.2552083333333333, dist.getVariance(), 0); + Assertions.assertEquals(0.375, dist.getMean(), 0); + Assertions.assertEquals(0.2552083333333333, dist.getVariance(), 0); } /** @@ -119,6 +118,6 @@ public class UniformContinuousDistributionTest extends ContinuousDistributionAbs public void testInverseCumulativeDistribution() { UniformContinuousDistribution dist = new UniformContinuousDistribution(0, 1e-9); - Assert.assertEquals(2.5e-10, dist.inverseCumulativeProbability(0.25), 0); + Assertions.assertEquals(2.5e-10, dist.inverseCumulativeProbability(0.25), 0); } } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/UniformDiscreteDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/UniformDiscreteDistributionTest.java index 393e964..740e073 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/UniformDiscreteDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/UniformDiscreteDistributionTest.java @@ -17,7 +17,6 @@ package org.apache.commons.statistics.distribution; -import org.junit.Assert; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -91,12 +90,12 @@ public class UniformDiscreteDistributionTest extends DiscreteDistributionAbstrac UniformDiscreteDistribution dist; dist = new UniformDiscreteDistribution(0, 5); - Assert.assertEquals(2.5, dist.getMean(), 0); - Assert.assertEquals(35 / 12.0, dist.getVariance(), 0); + Assertions.assertEquals(2.5, dist.getMean(), 0); + Assertions.assertEquals(35 / 12.0, dist.getVariance(), 0); dist = new UniformDiscreteDistribution(0, 1); - Assert.assertEquals(0.5, dist.getMean(), 0); - Assert.assertEquals(3 / 12.0, dist.getVariance(), 0); + Assertions.assertEquals(0.5, dist.getMean(), 0); + Assertions.assertEquals(3 / 12.0, dist.getVariance(), 0); } // MATH-1141 @@ -119,10 +118,10 @@ public class UniformDiscreteDistributionTest extends DiscreteDistributionAbstrac UniformDiscreteDistribution dist = new UniformDiscreteDistribution(-hi, hi - 1); final double tol = Math.ulp(1d); - Assert.assertEquals(0.5 / hi, dist.probability(123456), tol); - Assert.assertEquals(0.5, dist.cumulativeProbability(-1), tol); + Assertions.assertEquals(0.5 / hi, dist.probability(123456), tol); + Assertions.assertEquals(0.5, dist.cumulativeProbability(-1), tol); - Assert.assertTrue(Precision.equals((Math.pow(2d * hi, 2) - 1) / 12, dist.getVariance(), 1)); + Assertions.assertTrue(Precision.equals((Math.pow(2d * hi, 2) - 1) / 12, dist.getVariance(), 1)); } // MATH-1396 @@ -132,9 +131,9 @@ public class UniformDiscreteDistributionTest extends DiscreteDistributionAbstrac UniformDiscreteDistribution dist = new UniformDiscreteDistribution(hi - 1, hi + 1); final double tol = Math.ulp(1d); - Assert.assertEquals(1d / 3d, dist.probability(hi), tol); - Assert.assertEquals(2d / 3d, dist.cumulativeProbability(hi), tol); + Assertions.assertEquals(1d / 3d, dist.probability(hi), tol); + Assertions.assertEquals(2d / 3d, dist.cumulativeProbability(hi), tol); - Assert.assertTrue(Precision.equals(hi, dist.getMean(), 1)); + Assertions.assertTrue(Precision.equals(hi, dist.getMean(), 1)); } } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/WeibullDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/WeibullDistributionTest.java index 2d70983..b18bea0 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/WeibullDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/WeibullDistributionTest.java @@ -18,7 +18,6 @@ package org.apache.commons.statistics.distribution; import org.apache.commons.numbers.gamma.LogGamma; -import org.junit.Assert; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; @@ -68,7 +67,7 @@ public class WeibullDistributionTest extends ContinuousDistributionAbstractTest // Analytically, answer is solution to 1e-17 = 1-exp(-(x/3)^2) // x = sqrt(-9*log(1-1e-17)) // If we're not careful, answer will be 0. Answer below is computed with care in Octave: - Assert.assertEquals(9.48683298050514e-9, t, 1e-17); + Assertions.assertEquals(9.48683298050514e-9, t, 1e-17); } @Test @@ -81,7 +80,7 @@ public class WeibullDistributionTest extends ContinuousDistributionAbstractTest @Test public void testAlpha() { WeibullDistribution dist = new WeibullDistribution(1, 2); - Assert.assertEquals(1, dist.getShape(), 0); + Assertions.assertEquals(1, dist.getShape(), 0); } @Test public void testPrecondition1() { @@ -91,7 +90,7 @@ public class WeibullDistributionTest extends ContinuousDistributionAbstractTest @Test public void testBeta() { WeibullDistribution dist = new WeibullDistribution(1, 2); - Assert.assertEquals(2, dist.getScale(), 0); + Assertions.assertEquals(2, dist.getScale(), 0); } @Test public void testPrecondition2() { @@ -105,14 +104,14 @@ public class WeibullDistributionTest extends ContinuousDistributionAbstractTest dist = new WeibullDistribution(2.5, 3.5); // In R: 3.5*gamma(1+(1/2.5)) (or empirically: mean(rweibull(10000, 2.5, 3.5))) - Assert.assertEquals(3.5 * Math.exp(LogGamma.value(1 + (1 / 2.5))), dist.getMean(), tol); - Assert.assertEquals((3.5 * 3.5) * + Assertions.assertEquals(3.5 * Math.exp(LogGamma.value(1 + (1 / 2.5))), dist.getMean(), tol); + Assertions.assertEquals((3.5 * 3.5) * Math.exp(LogGamma.value(1 + (2 / 2.5))) - (dist.getMean() * dist.getMean()), dist.getVariance(), tol); dist = new WeibullDistribution(10.4, 2.222); - Assert.assertEquals(2.222 * Math.exp(LogGamma.value(1 + (1 / 10.4))), dist.getMean(), tol); - Assert.assertEquals((2.222 * 2.222) * + Assertions.assertEquals(2.222 * Math.exp(LogGamma.value(1 + (1 / 10.4))), dist.getMean(), tol); + Assertions.assertEquals((2.222 * 2.222) * Math.exp(LogGamma.value(1 + (2 / 10.4))) - (dist.getMean() * dist.getMean()), dist.getVariance(), tol); } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ZipfDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ZipfDistributionTest.java index a20160b..e548c6e 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ZipfDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ZipfDistributionTest.java @@ -18,7 +18,6 @@ package org.apache.commons.statistics.distribution; import org.apache.commons.rng.simple.RandomSource; -import org.junit.Assert; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -115,8 +114,8 @@ public class ZipfDistributionTest extends DiscreteDistributionAbstractTest { ZipfDistribution dist; dist = new ZipfDistribution(2, 0.5); - Assert.assertEquals(Math.sqrt(2), dist.getMean(), tol); - Assert.assertEquals(0.24264068711928521, dist.getVariance(), tol); + Assertions.assertEquals(Math.sqrt(2), dist.getMean(), tol); + Assertions.assertEquals(0.24264068711928521, dist.getVariance(), tol); } /**
