You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by lu...@apache.org on 2011/03/20 18:24:19 UTC

svn commit: r1083514 [14/15] - in /commons/proper/math/trunk/src/test/java/org/apache/commons/math: ./ analysis/integration/ analysis/interpolation/ analysis/polynomials/ analysis/solvers/ complex/ distribution/ fraction/ genetics/ geometry/ linear/ od...

Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/MathUtilsTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/MathUtilsTest.java?rev=1083514&r1=1083513&r2=1083514&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/MathUtilsTest.java (original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/MathUtilsTest.java Sun Mar 20 17:24:14 2011
@@ -20,7 +20,6 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
-import junit.framework.TestCase;
 
 import org.apache.commons.math.TestUtils;
 import org.apache.commons.math.exception.NonMonotonousSequenceException;
@@ -31,17 +30,15 @@ import org.apache.commons.math.exception
 import org.apache.commons.math.exception.NullArgumentException;
 import org.apache.commons.math.exception.util.LocalizedFormats;
 import org.apache.commons.math.random.RandomDataImpl;
+import org.junit.Assert;
+import org.junit.Test;
 
 /**
  * Test cases for the MathUtils class.
  * @version $Revision$ $Date: 2007-08-16 15:36:33 -0500 (Thu, 16 Aug
  *          2007) $
  */
-public final class MathUtilsTest extends TestCase {
-
-    public MathUtilsTest(String name) {
-        super(name);
-    }
+public final class MathUtilsTest {
 
     /** cached binomial coefficients */
     private static final List<Map<Integer, Long>> binomialCache = new ArrayList<Map<Integer, Long>>();
@@ -94,39 +91,42 @@ public final class MathUtilsTest extends
     }
 
     /** Verify that b(0,0) = 1 */
+    @Test
     public void test0Choose0() {
-        assertEquals(MathUtils.binomialCoefficientDouble(0, 0), 1d, 0);
-        assertEquals(MathUtils.binomialCoefficientLog(0, 0), 0d, 0);
-        assertEquals(MathUtils.binomialCoefficient(0, 0), 1);
+        Assert.assertEquals(MathUtils.binomialCoefficientDouble(0, 0), 1d, 0);
+        Assert.assertEquals(MathUtils.binomialCoefficientLog(0, 0), 0d, 0);
+        Assert.assertEquals(MathUtils.binomialCoefficient(0, 0), 1);
     }
 
+    @Test
     public void testAddAndCheck() {
         int big = Integer.MAX_VALUE;
         int bigNeg = Integer.MIN_VALUE;
-        assertEquals(big, MathUtils.addAndCheck(big, 0));
+        Assert.assertEquals(big, MathUtils.addAndCheck(big, 0));
         try {
             MathUtils.addAndCheck(big, 1);
-            fail("Expecting MathArithmeticException");
+            Assert.fail("Expecting MathArithmeticException");
         } catch (MathArithmeticException ex) {
         }
         try {
             MathUtils.addAndCheck(bigNeg, -1);
-            fail("Expecting MathArithmeticException");
+            Assert.fail("Expecting MathArithmeticException");
         } catch (MathArithmeticException ex) {
         }
     }
 
+    @Test
     public void testAddAndCheckLong() {
         long max = Long.MAX_VALUE;
         long min = Long.MIN_VALUE;
-        assertEquals(max, MathUtils.addAndCheck(max, 0L));
-        assertEquals(min, MathUtils.addAndCheck(min, 0L));
-        assertEquals(max, MathUtils.addAndCheck(0L, max));
-        assertEquals(min, MathUtils.addAndCheck(0L, min));
-        assertEquals(1, MathUtils.addAndCheck(-1L, 2L));
-        assertEquals(1, MathUtils.addAndCheck(2L, -1L));
-        assertEquals(-3, MathUtils.addAndCheck(-2L, -1L));
-        assertEquals(min, MathUtils.addAndCheck(min + 1, -1L));
+        Assert.assertEquals(max, MathUtils.addAndCheck(max, 0L));
+        Assert.assertEquals(min, MathUtils.addAndCheck(min, 0L));
+        Assert.assertEquals(max, MathUtils.addAndCheck(0L, max));
+        Assert.assertEquals(min, MathUtils.addAndCheck(0L, min));
+        Assert.assertEquals(1, MathUtils.addAndCheck(-1L, 2L));
+        Assert.assertEquals(1, MathUtils.addAndCheck(2L, -1L));
+        Assert.assertEquals(-3, MathUtils.addAndCheck(-2L, -1L));
+        Assert.assertEquals(min, MathUtils.addAndCheck(min + 1, -1L));
         testAddAndCheckLongFailure(max, 1L);
         testAddAndCheckLongFailure(min, -1L);
         testAddAndCheckLongFailure(1L, max);
@@ -136,12 +136,13 @@ public final class MathUtilsTest extends
     private void testAddAndCheckLongFailure(long a, long b) {
         try {
             MathUtils.addAndCheck(a, b);
-            fail("Expecting MathArithmeticException");
+            Assert.fail("Expecting MathArithmeticException");
         } catch (MathArithmeticException ex) {
             // success
         }
     }
 
+    @Test
     public void testBinomialCoefficient() {
         long[] bcoef5 = {
             1,
@@ -159,17 +160,17 @@ public final class MathUtilsTest extends
             6,
             1 };
         for (int i = 0; i < 6; i++) {
-            assertEquals("5 choose " + i, bcoef5[i], MathUtils.binomialCoefficient(5, i));
+            Assert.assertEquals("5 choose " + i, bcoef5[i], MathUtils.binomialCoefficient(5, i));
         }
         for (int i = 0; i < 7; i++) {
-            assertEquals("6 choose " + i, bcoef6[i], MathUtils.binomialCoefficient(6, i));
+            Assert.assertEquals("6 choose " + i, bcoef6[i], MathUtils.binomialCoefficient(6, i));
         }
 
         for (int n = 1; n < 10; n++) {
             for (int k = 0; k <= n; k++) {
-                assertEquals(n + " choose " + k, binomialCoefficient(n, k), MathUtils.binomialCoefficient(n, k));
-                assertEquals(n + " choose " + k, binomialCoefficient(n, k), MathUtils.binomialCoefficientDouble(n, k), Double.MIN_VALUE);
-                assertEquals(n + " choose " + k, FastMath.log(binomialCoefficient(n, k)), MathUtils.binomialCoefficientLog(n, k), 10E-12);
+                Assert.assertEquals(n + " choose " + k, binomialCoefficient(n, k), MathUtils.binomialCoefficient(n, k));
+                Assert.assertEquals(n + " choose " + k, binomialCoefficient(n, k), MathUtils.binomialCoefficientDouble(n, k), Double.MIN_VALUE);
+                Assert.assertEquals(n + " choose " + k, FastMath.log(binomialCoefficient(n, k)), MathUtils.binomialCoefficientLog(n, k), 10E-12);
             }
         }
 
@@ -177,11 +178,11 @@ public final class MathUtilsTest extends
         int[] k = { 17, 33, 10, 1500 - 4, 4 };
         for (int i = 0; i < n.length; i++) {
             long expected = binomialCoefficient(n[i], k[i]);
-            assertEquals(n[i] + " choose " + k[i], expected,
+            Assert.assertEquals(n[i] + " choose " + k[i], expected,
                 MathUtils.binomialCoefficient(n[i], k[i]));
-            assertEquals(n[i] + " choose " + k[i], expected,
+            Assert.assertEquals(n[i] + " choose " + k[i], expected,
                 MathUtils.binomialCoefficientDouble(n[i], k[i]), 0.0);
-            assertEquals("log(" + n[i] + " choose " + k[i] + ")", FastMath.log(expected),
+            Assert.assertEquals("log(" + n[i] + " choose " + k[i] + ")", FastMath.log(expected),
                 MathUtils.binomialCoefficientLog(n[i], k[i]), 0.0);
         }
     }
@@ -190,6 +191,7 @@ public final class MathUtilsTest extends
      * Tests correctness for large n and sharpness of upper bound in API doc
      * JIRA: MATH-241
      */
+    @Test
     public void testBinomialCoefficientLarge() throws Exception {
         // This tests all legal and illegal values for n <= 200.
         for (int n = 0; n <= 200; n++) {
@@ -208,14 +210,14 @@ public final class MathUtilsTest extends
                 } catch (MathArithmeticException ex) {
                     shouldThrow = true;
                 }
-                assertEquals(n + " choose " + k, exactResult, ourResult);
-                assertEquals(n + " choose " + k, shouldThrow, didThrow);
-                assertTrue(n + " choose " + k, (n > 66 || !didThrow));
+                Assert.assertEquals(n + " choose " + k, exactResult, ourResult);
+                Assert.assertEquals(n + " choose " + k, shouldThrow, didThrow);
+                Assert.assertTrue(n + " choose " + k, (n > 66 || !didThrow));
 
                 if (!shouldThrow && exactResult > 1) {
-                    assertEquals(n + " choose " + k, 1.,
+                    Assert.assertEquals(n + " choose " + k, 1.,
                         MathUtils.binomialCoefficientDouble(n, k) / exactResult, 1e-10);
-                    assertEquals(n + " choose " + k, 1,
+                    Assert.assertEquals(n + " choose " + k, 1,
                         MathUtils.binomialCoefficientLog(n, k) / FastMath.log(exactResult), 1e-10);
                 }
             }
@@ -223,16 +225,16 @@ public final class MathUtilsTest extends
 
         long ourResult = MathUtils.binomialCoefficient(300, 3);
         long exactResult = binomialCoefficient(300, 3);
-        assertEquals(exactResult, ourResult);
+        Assert.assertEquals(exactResult, ourResult);
 
         ourResult = MathUtils.binomialCoefficient(700, 697);
         exactResult = binomialCoefficient(700, 697);
-        assertEquals(exactResult, ourResult);
+        Assert.assertEquals(exactResult, ourResult);
 
         // This one should throw
         try {
             MathUtils.binomialCoefficient(700, 300);
-            fail("Expecting MathArithmeticException");
+            Assert.fail("Expecting MathArithmeticException");
         } catch (MathArithmeticException ex) {
             // Expected
         }
@@ -240,86 +242,91 @@ public final class MathUtilsTest extends
         int n = 10000;
         ourResult = MathUtils.binomialCoefficient(n, 3);
         exactResult = binomialCoefficient(n, 3);
-        assertEquals(exactResult, ourResult);
-        assertEquals(1, MathUtils.binomialCoefficientDouble(n, 3) / exactResult, 1e-10);
-        assertEquals(1, MathUtils.binomialCoefficientLog(n, 3) / FastMath.log(exactResult), 1e-10);
+        Assert.assertEquals(exactResult, ourResult);
+        Assert.assertEquals(1, MathUtils.binomialCoefficientDouble(n, 3) / exactResult, 1e-10);
+        Assert.assertEquals(1, MathUtils.binomialCoefficientLog(n, 3) / FastMath.log(exactResult), 1e-10);
 
     }
 
+    @Test
     public void testBinomialCoefficientFail() {
         try {
             MathUtils.binomialCoefficient(4, 5);
-            fail("expecting MathIllegalArgumentException");
+            Assert.fail("expecting MathIllegalArgumentException");
         } catch (MathIllegalArgumentException ex) {
             // ignored
         }
 
         try {
             MathUtils.binomialCoefficientDouble(4, 5);
-            fail("expecting MathIllegalArgumentException");
+            Assert.fail("expecting MathIllegalArgumentException");
         } catch (MathIllegalArgumentException ex) {
             // ignored
         }
 
         try {
             MathUtils.binomialCoefficientLog(4, 5);
-            fail("expecting MathIllegalArgumentException");
+            Assert.fail("expecting MathIllegalArgumentException");
         } catch (MathIllegalArgumentException ex) {
             // ignored
         }
 
         try {
             MathUtils.binomialCoefficient(-1, -2);
-            fail("expecting MathIllegalArgumentException");
+            Assert.fail("expecting MathIllegalArgumentException");
         } catch (MathIllegalArgumentException ex) {
             // ignored
         }
         try {
             MathUtils.binomialCoefficientDouble(-1, -2);
-            fail("expecting MathIllegalArgumentException");
+            Assert.fail("expecting MathIllegalArgumentException");
         } catch (MathIllegalArgumentException ex) {
             // ignored
         }
         try {
             MathUtils.binomialCoefficientLog(-1, -2);
-            fail("expecting MathIllegalArgumentException");
+            Assert.fail("expecting MathIllegalArgumentException");
         } catch (MathIllegalArgumentException ex) {
             // ignored
         }
 
         try {
             MathUtils.binomialCoefficient(67, 30);
-            fail("expecting MathArithmeticException");
+            Assert.fail("expecting MathArithmeticException");
         } catch (MathArithmeticException ex) {
             // ignored
         }
         try {
             MathUtils.binomialCoefficient(67, 34);
-            fail("expecting MathArithmeticException");
+            Assert.fail("expecting MathArithmeticException");
         } catch (MathArithmeticException ex) {
             // ignored
         }
         double x = MathUtils.binomialCoefficientDouble(1030, 515);
-        assertTrue("expecting infinite binomial coefficient", Double
+        Assert.assertTrue("expecting infinite binomial coefficient", Double
             .isInfinite(x));
     }
 
+    @Test
     public void testCompareTo() {
-      assertEquals(0, MathUtils.compareTo(152.33, 152.32, .011));
-      assertTrue(MathUtils.compareTo(152.308, 152.32, .011) < 0);
-      assertTrue(MathUtils.compareTo(152.33, 152.318, .011) > 0);
+      Assert.assertEquals(0, MathUtils.compareTo(152.33, 152.32, .011));
+      Assert.assertTrue(MathUtils.compareTo(152.308, 152.32, .011) < 0);
+      Assert.assertTrue(MathUtils.compareTo(152.33, 152.318, .011) > 0);
     }
 
+    @Test
     public void testCosh() {
         double x = 3.0;
         double expected = 10.06766;
-        assertEquals(expected, MathUtils.cosh(x), 1.0e-5);
+        Assert.assertEquals(expected, MathUtils.cosh(x), 1.0e-5);
     }
 
+    @Test
     public void testCoshNaN() {
-        assertTrue(Double.isNaN(MathUtils.cosh(Double.NaN)));
+        Assert.assertTrue(Double.isNaN(MathUtils.cosh(Double.NaN)));
     }
 
+    @Test
     public void testEqualsIncludingNaN() {
         double[] testArray = {
             Double.NaN,
@@ -330,28 +337,30 @@ public final class MathUtilsTest extends
         for (int i = 0; i < testArray.length; i++) {
             for (int j = 0; j < testArray.length; j++) {
                 if (i == j) {
-                    assertTrue(MathUtils.equalsIncludingNaN(testArray[i], testArray[j]));
-                    assertTrue(MathUtils.equalsIncludingNaN(testArray[j], testArray[i]));
+                    Assert.assertTrue(MathUtils.equalsIncludingNaN(testArray[i], testArray[j]));
+                    Assert.assertTrue(MathUtils.equalsIncludingNaN(testArray[j], testArray[i]));
                 } else {
-                    assertTrue(!MathUtils.equalsIncludingNaN(testArray[i], testArray[j]));
-                    assertTrue(!MathUtils.equalsIncludingNaN(testArray[j], testArray[i]));
+                    Assert.assertTrue(!MathUtils.equalsIncludingNaN(testArray[i], testArray[j]));
+                    Assert.assertTrue(!MathUtils.equalsIncludingNaN(testArray[j], testArray[i]));
                 }
             }
         }
     }
 
+    @Test
     public void testEqualsWithAllowedDelta() {
-        assertTrue(MathUtils.equals(153.0000, 153.0000, .0625));
-        assertTrue(MathUtils.equals(153.0000, 153.0625, .0625));
-        assertTrue(MathUtils.equals(152.9375, 153.0000, .0625));
-        assertFalse(MathUtils.equals(153.0000, 153.0625, .0624));
-        assertFalse(MathUtils.equals(152.9374, 153.0000, .0625));
-        assertFalse(MathUtils.equals(Double.NaN, Double.NaN, 1.0));
-        assertTrue(MathUtils.equals(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, 1.0));
-        assertTrue(MathUtils.equals(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, 1.0));
-        assertFalse(MathUtils.equals(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 1.0));
+        Assert.assertTrue(MathUtils.equals(153.0000, 153.0000, .0625));
+        Assert.assertTrue(MathUtils.equals(153.0000, 153.0625, .0625));
+        Assert.assertTrue(MathUtils.equals(152.9375, 153.0000, .0625));
+        Assert.assertFalse(MathUtils.equals(153.0000, 153.0625, .0624));
+        Assert.assertFalse(MathUtils.equals(152.9374, 153.0000, .0625));
+        Assert.assertFalse(MathUtils.equals(Double.NaN, Double.NaN, 1.0));
+        Assert.assertTrue(MathUtils.equals(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, 1.0));
+        Assert.assertTrue(MathUtils.equals(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, 1.0));
+        Assert.assertFalse(MathUtils.equals(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 1.0));
     }
 
+    @Test
     public void testMath475() {
         final double a = 1.7976931348623182E16;
         final double b = FastMath.nextUp(a);
@@ -360,322 +369,333 @@ public final class MathUtilsTest extends
         // Because they are adjacent floating point numbers, "a" and "b" are
         // considered equal even though the allowed error is smaller than
         // their difference.
-        assertTrue(MathUtils.equals(a, b, 0.5 * diff));
+        Assert.assertTrue(MathUtils.equals(a, b, 0.5 * diff));
 
         final double c = FastMath.nextUp(b);
         diff = FastMath.abs(a - c);
         // Because "a" and "c" are not adjacent, the tolerance is taken into
         // account for assessing equality.
-        assertTrue(MathUtils.equals(a, c, diff));
-        assertFalse(MathUtils.equals(a, c, (1 - 1e-16) * diff));
+        Assert.assertTrue(MathUtils.equals(a, c, diff));
+        Assert.assertFalse(MathUtils.equals(a, c, (1 - 1e-16) * diff));
     }
 
+    @Test
     public void testEqualsIncludingNaNWithAllowedDelta() {
-        assertTrue(MathUtils.equalsIncludingNaN(153.0000, 153.0000, .0625));
-        assertTrue(MathUtils.equalsIncludingNaN(153.0000, 153.0625, .0625));
-        assertTrue(MathUtils.equalsIncludingNaN(152.9375, 153.0000, .0625));
-        assertTrue(MathUtils.equalsIncludingNaN(Double.NaN, Double.NaN, 1.0));
-        assertTrue(MathUtils.equalsIncludingNaN(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, 1.0));
-        assertTrue(MathUtils.equalsIncludingNaN(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, 1.0));
-        assertFalse(MathUtils.equalsIncludingNaN(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 1.0));
-        assertFalse(MathUtils.equalsIncludingNaN(153.0000, 153.0625, .0624));
-        assertFalse(MathUtils.equalsIncludingNaN(152.9374, 153.0000, .0625));
+        Assert.assertTrue(MathUtils.equalsIncludingNaN(153.0000, 153.0000, .0625));
+        Assert.assertTrue(MathUtils.equalsIncludingNaN(153.0000, 153.0625, .0625));
+        Assert.assertTrue(MathUtils.equalsIncludingNaN(152.9375, 153.0000, .0625));
+        Assert.assertTrue(MathUtils.equalsIncludingNaN(Double.NaN, Double.NaN, 1.0));
+        Assert.assertTrue(MathUtils.equalsIncludingNaN(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, 1.0));
+        Assert.assertTrue(MathUtils.equalsIncludingNaN(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, 1.0));
+        Assert.assertFalse(MathUtils.equalsIncludingNaN(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 1.0));
+        Assert.assertFalse(MathUtils.equalsIncludingNaN(153.0000, 153.0625, .0624));
+        Assert.assertFalse(MathUtils.equalsIncludingNaN(152.9374, 153.0000, .0625));
     }
 
     // Tests for floating point equality
+    @Test
     public void testFloatEqualsWithAllowedUlps() {
-        assertTrue("+0.0f == -0.0f",MathUtils.equals(0.0f, -0.0f));
-        assertTrue("+0.0f == -0.0f (1 ulp)",MathUtils.equals(0.0f, -0.0f, 1));
+        Assert.assertTrue("+0.0f == -0.0f",MathUtils.equals(0.0f, -0.0f));
+        Assert.assertTrue("+0.0f == -0.0f (1 ulp)",MathUtils.equals(0.0f, -0.0f, 1));
         float oneFloat = 1.0f;
-        assertTrue("1.0f == 1.0f + 1 ulp",MathUtils.equals(oneFloat, Float.intBitsToFloat(1 + Float.floatToIntBits(oneFloat))));
-        assertTrue("1.0f == 1.0f + 1 ulp (1 ulp)",MathUtils.equals(oneFloat, Float.intBitsToFloat(1 + Float.floatToIntBits(oneFloat)), 1));
-        assertFalse("1.0f != 1.0f + 2 ulp (1 ulp)",MathUtils.equals(oneFloat, Float.intBitsToFloat(2 + Float.floatToIntBits(oneFloat)), 1));
+        Assert.assertTrue("1.0f == 1.0f + 1 ulp",MathUtils.equals(oneFloat, Float.intBitsToFloat(1 + Float.floatToIntBits(oneFloat))));
+        Assert.assertTrue("1.0f == 1.0f + 1 ulp (1 ulp)",MathUtils.equals(oneFloat, Float.intBitsToFloat(1 + Float.floatToIntBits(oneFloat)), 1));
+        Assert.assertFalse("1.0f != 1.0f + 2 ulp (1 ulp)",MathUtils.equals(oneFloat, Float.intBitsToFloat(2 + Float.floatToIntBits(oneFloat)), 1));
 
-        assertTrue(MathUtils.equals(153.0f, 153.0f, 1));
+        Assert.assertTrue(MathUtils.equals(153.0f, 153.0f, 1));
 
         // These tests need adjusting for floating point precision
-//        assertTrue(MathUtils.equals(153.0f, 153.00000000000003f, 1));
-//        assertFalse(MathUtils.equals(153.0f, 153.00000000000006f, 1));
-//        assertTrue(MathUtils.equals(153.0f, 152.99999999999997f, 1));
-//        assertFalse(MathUtils.equals(153f, 152.99999999999994f, 1));
+//        Assert.assertTrue(MathUtils.equals(153.0f, 153.00000000000003f, 1));
+//        Assert.assertFalse(MathUtils.equals(153.0f, 153.00000000000006f, 1));
+//        Assert.assertTrue(MathUtils.equals(153.0f, 152.99999999999997f, 1));
+//        Assert.assertFalse(MathUtils.equals(153f, 152.99999999999994f, 1));
 //
-//        assertTrue(MathUtils.equals(-128.0f, -127.99999999999999f, 1));
-//        assertFalse(MathUtils.equals(-128.0f, -127.99999999999997f, 1));
-//        assertTrue(MathUtils.equals(-128.0f, -128.00000000000003f, 1));
-//        assertFalse(MathUtils.equals(-128.0f, -128.00000000000006f, 1));
+//        Assert.assertTrue(MathUtils.equals(-128.0f, -127.99999999999999f, 1));
+//        Assert.assertFalse(MathUtils.equals(-128.0f, -127.99999999999997f, 1));
+//        Assert.assertTrue(MathUtils.equals(-128.0f, -128.00000000000003f, 1));
+//        Assert.assertFalse(MathUtils.equals(-128.0f, -128.00000000000006f, 1));
 
-        assertTrue(MathUtils.equals(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY, 1));
-        assertTrue(MathUtils.equals(Double.MAX_VALUE, Float.POSITIVE_INFINITY, 1));
+        Assert.assertTrue(MathUtils.equals(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY, 1));
+        Assert.assertTrue(MathUtils.equals(Double.MAX_VALUE, Float.POSITIVE_INFINITY, 1));
 
-        assertTrue(MathUtils.equals(Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY, 1));
-        assertTrue(MathUtils.equals(-Float.MAX_VALUE, Float.NEGATIVE_INFINITY, 1));
+        Assert.assertTrue(MathUtils.equals(Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY, 1));
+        Assert.assertTrue(MathUtils.equals(-Float.MAX_VALUE, Float.NEGATIVE_INFINITY, 1));
 
-        assertFalse(MathUtils.equals(Float.NaN, Float.NaN, 1));
+        Assert.assertFalse(MathUtils.equals(Float.NaN, Float.NaN, 1));
 
-        assertFalse(MathUtils.equals(Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY, 100000));
+        Assert.assertFalse(MathUtils.equals(Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY, 100000));
     }
 
+    @Test
     public void testEqualsWithAllowedUlps() {
-        assertTrue(MathUtils.equals(0.0, -0.0, 1));
+        Assert.assertTrue(MathUtils.equals(0.0, -0.0, 1));
 
-        assertTrue(MathUtils.equals(1.0, 1 + FastMath.ulp(1d), 1));
-        assertFalse(MathUtils.equals(1.0, 1 + 2 * FastMath.ulp(1d), 1));
+        Assert.assertTrue(MathUtils.equals(1.0, 1 + FastMath.ulp(1d), 1));
+        Assert.assertFalse(MathUtils.equals(1.0, 1 + 2 * FastMath.ulp(1d), 1));
 
         final double nUp1 = FastMath.nextAfter(1d, Double.POSITIVE_INFINITY);
         final double nnUp1 = FastMath.nextAfter(nUp1, Double.POSITIVE_INFINITY);
-        assertTrue(MathUtils.equals(1.0, nUp1, 1));
-        assertTrue(MathUtils.equals(nUp1, nnUp1, 1));
-        assertFalse(MathUtils.equals(1.0, nnUp1, 1));
+        Assert.assertTrue(MathUtils.equals(1.0, nUp1, 1));
+        Assert.assertTrue(MathUtils.equals(nUp1, nnUp1, 1));
+        Assert.assertFalse(MathUtils.equals(1.0, nnUp1, 1));
 
-        assertTrue(MathUtils.equals(0.0, FastMath.ulp(0d), 1));
-        assertTrue(MathUtils.equals(0.0, -FastMath.ulp(0d), 1));
+        Assert.assertTrue(MathUtils.equals(0.0, FastMath.ulp(0d), 1));
+        Assert.assertTrue(MathUtils.equals(0.0, -FastMath.ulp(0d), 1));
 
-        assertTrue(MathUtils.equals(153.0, 153.0, 1));
+        Assert.assertTrue(MathUtils.equals(153.0, 153.0, 1));
 
-        assertTrue(MathUtils.equals(153.0, 153.00000000000003, 1));
-        assertFalse(MathUtils.equals(153.0, 153.00000000000006, 1));
-        assertTrue(MathUtils.equals(153.0, 152.99999999999997, 1));
-        assertFalse(MathUtils.equals(153, 152.99999999999994, 1));
+        Assert.assertTrue(MathUtils.equals(153.0, 153.00000000000003, 1));
+        Assert.assertFalse(MathUtils.equals(153.0, 153.00000000000006, 1));
+        Assert.assertTrue(MathUtils.equals(153.0, 152.99999999999997, 1));
+        Assert.assertFalse(MathUtils.equals(153, 152.99999999999994, 1));
 
-        assertTrue(MathUtils.equals(-128.0, -127.99999999999999, 1));
-        assertFalse(MathUtils.equals(-128.0, -127.99999999999997, 1));
-        assertTrue(MathUtils.equals(-128.0, -128.00000000000003, 1));
-        assertFalse(MathUtils.equals(-128.0, -128.00000000000006, 1));
+        Assert.assertTrue(MathUtils.equals(-128.0, -127.99999999999999, 1));
+        Assert.assertFalse(MathUtils.equals(-128.0, -127.99999999999997, 1));
+        Assert.assertTrue(MathUtils.equals(-128.0, -128.00000000000003, 1));
+        Assert.assertFalse(MathUtils.equals(-128.0, -128.00000000000006, 1));
 
-        assertTrue(MathUtils.equals(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, 1));
-        assertTrue(MathUtils.equals(Double.MAX_VALUE, Double.POSITIVE_INFINITY, 1));
+        Assert.assertTrue(MathUtils.equals(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, 1));
+        Assert.assertTrue(MathUtils.equals(Double.MAX_VALUE, Double.POSITIVE_INFINITY, 1));
 
-        assertTrue(MathUtils.equals(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, 1));
-        assertTrue(MathUtils.equals(-Double.MAX_VALUE, Double.NEGATIVE_INFINITY, 1));
+        Assert.assertTrue(MathUtils.equals(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, 1));
+        Assert.assertTrue(MathUtils.equals(-Double.MAX_VALUE, Double.NEGATIVE_INFINITY, 1));
 
-        assertFalse(MathUtils.equals(Double.NaN, Double.NaN, 1));
+        Assert.assertFalse(MathUtils.equals(Double.NaN, Double.NaN, 1));
 
-        assertFalse(MathUtils.equals(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 100000));
+        Assert.assertFalse(MathUtils.equals(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 100000));
     }
 
+    @Test
     public void testEqualsIncludingNaNWithAllowedUlps() {
-        assertTrue(MathUtils.equalsIncludingNaN(0.0, -0.0, 1));
+        Assert.assertTrue(MathUtils.equalsIncludingNaN(0.0, -0.0, 1));
 
-        assertTrue(MathUtils.equalsIncludingNaN(1.0, 1 + FastMath.ulp(1d), 1));
-        assertFalse(MathUtils.equalsIncludingNaN(1.0, 1 + 2 * FastMath.ulp(1d), 1));
+        Assert.assertTrue(MathUtils.equalsIncludingNaN(1.0, 1 + FastMath.ulp(1d), 1));
+        Assert.assertFalse(MathUtils.equalsIncludingNaN(1.0, 1 + 2 * FastMath.ulp(1d), 1));
 
         final double nUp1 = FastMath.nextAfter(1d, Double.POSITIVE_INFINITY);
         final double nnUp1 = FastMath.nextAfter(nUp1, Double.POSITIVE_INFINITY);
-        assertTrue(MathUtils.equalsIncludingNaN(1.0, nUp1, 1));
-        assertTrue(MathUtils.equalsIncludingNaN(nUp1, nnUp1, 1));
-        assertFalse(MathUtils.equalsIncludingNaN(1.0, nnUp1, 1));
+        Assert.assertTrue(MathUtils.equalsIncludingNaN(1.0, nUp1, 1));
+        Assert.assertTrue(MathUtils.equalsIncludingNaN(nUp1, nnUp1, 1));
+        Assert.assertFalse(MathUtils.equalsIncludingNaN(1.0, nnUp1, 1));
 
-        assertTrue(MathUtils.equalsIncludingNaN(0.0, FastMath.ulp(0d), 1));
-        assertTrue(MathUtils.equalsIncludingNaN(0.0, -FastMath.ulp(0d), 1));
+        Assert.assertTrue(MathUtils.equalsIncludingNaN(0.0, FastMath.ulp(0d), 1));
+        Assert.assertTrue(MathUtils.equalsIncludingNaN(0.0, -FastMath.ulp(0d), 1));
 
-        assertTrue(MathUtils.equalsIncludingNaN(153.0, 153.0, 1));
+        Assert.assertTrue(MathUtils.equalsIncludingNaN(153.0, 153.0, 1));
 
-        assertTrue(MathUtils.equalsIncludingNaN(153.0, 153.00000000000003, 1));
-        assertFalse(MathUtils.equalsIncludingNaN(153.0, 153.00000000000006, 1));
-        assertTrue(MathUtils.equalsIncludingNaN(153.0, 152.99999999999997, 1));
-        assertFalse(MathUtils.equalsIncludingNaN(153, 152.99999999999994, 1));
+        Assert.assertTrue(MathUtils.equalsIncludingNaN(153.0, 153.00000000000003, 1));
+        Assert.assertFalse(MathUtils.equalsIncludingNaN(153.0, 153.00000000000006, 1));
+        Assert.assertTrue(MathUtils.equalsIncludingNaN(153.0, 152.99999999999997, 1));
+        Assert.assertFalse(MathUtils.equalsIncludingNaN(153, 152.99999999999994, 1));
 
-        assertTrue(MathUtils.equalsIncludingNaN(-128.0, -127.99999999999999, 1));
-        assertFalse(MathUtils.equalsIncludingNaN(-128.0, -127.99999999999997, 1));
-        assertTrue(MathUtils.equalsIncludingNaN(-128.0, -128.00000000000003, 1));
-        assertFalse(MathUtils.equalsIncludingNaN(-128.0, -128.00000000000006, 1));
+        Assert.assertTrue(MathUtils.equalsIncludingNaN(-128.0, -127.99999999999999, 1));
+        Assert.assertFalse(MathUtils.equalsIncludingNaN(-128.0, -127.99999999999997, 1));
+        Assert.assertTrue(MathUtils.equalsIncludingNaN(-128.0, -128.00000000000003, 1));
+        Assert.assertFalse(MathUtils.equalsIncludingNaN(-128.0, -128.00000000000006, 1));
 
-        assertTrue(MathUtils.equalsIncludingNaN(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, 1));
-        assertTrue(MathUtils.equalsIncludingNaN(Double.MAX_VALUE, Double.POSITIVE_INFINITY, 1));
+        Assert.assertTrue(MathUtils.equalsIncludingNaN(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, 1));
+        Assert.assertTrue(MathUtils.equalsIncludingNaN(Double.MAX_VALUE, Double.POSITIVE_INFINITY, 1));
 
-        assertTrue(MathUtils.equalsIncludingNaN(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, 1));
-        assertTrue(MathUtils.equalsIncludingNaN(-Double.MAX_VALUE, Double.NEGATIVE_INFINITY, 1));
+        Assert.assertTrue(MathUtils.equalsIncludingNaN(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, 1));
+        Assert.assertTrue(MathUtils.equalsIncludingNaN(-Double.MAX_VALUE, Double.NEGATIVE_INFINITY, 1));
 
-        assertTrue(MathUtils.equalsIncludingNaN(Double.NaN, Double.NaN, 1));
+        Assert.assertTrue(MathUtils.equalsIncludingNaN(Double.NaN, Double.NaN, 1));
 
-        assertFalse(MathUtils.equalsIncludingNaN(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 100000));
+        Assert.assertFalse(MathUtils.equalsIncludingNaN(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 100000));
     }
 
+    @Test
     public void testArrayEquals() {
-        assertFalse(MathUtils.equals(new double[] { 1d }, null));
-        assertFalse(MathUtils.equals(null, new double[] { 1d }));
-        assertTrue(MathUtils.equals((double[]) null, (double[]) null));
-
-        assertFalse(MathUtils.equals(new double[] { 1d }, new double[0]));
-        assertTrue(MathUtils.equals(new double[] { 1d }, new double[] { 1d }));
-        assertTrue(MathUtils.equals(new double[] {
+        Assert.assertFalse(MathUtils.equals(new double[] { 1d }, null));
+        Assert.assertFalse(MathUtils.equals(null, new double[] { 1d }));
+        Assert.assertTrue(MathUtils.equals((double[]) null, (double[]) null));
+
+        Assert.assertFalse(MathUtils.equals(new double[] { 1d }, new double[0]));
+        Assert.assertTrue(MathUtils.equals(new double[] { 1d }, new double[] { 1d }));
+        Assert.assertTrue(MathUtils.equals(new double[] {
                                       Double.POSITIVE_INFINITY,
                                       Double.NEGATIVE_INFINITY, 1d, 0d
                                     }, new double[] {
                                       Double.POSITIVE_INFINITY,
                                       Double.NEGATIVE_INFINITY, 1d, 0d
                                     }));
-        assertFalse(MathUtils.equals(new double[] { Double.NaN },
+        Assert.assertFalse(MathUtils.equals(new double[] { Double.NaN },
                                      new double[] { Double.NaN }));
-        assertFalse(MathUtils.equals(new double[] { Double.POSITIVE_INFINITY },
+        Assert.assertFalse(MathUtils.equals(new double[] { Double.POSITIVE_INFINITY },
                                      new double[] { Double.NEGATIVE_INFINITY }));
-        assertFalse(MathUtils.equals(new double[] { 1d },
+        Assert.assertFalse(MathUtils.equals(new double[] { 1d },
                                      new double[] { FastMath.nextAfter(FastMath.nextAfter(1d, 2d), 2d) }));
 
     }
 
+    @Test
     public void testArrayEqualsIncludingNaN() {
-        assertFalse(MathUtils.equalsIncludingNaN(new double[] { 1d }, null));
-        assertFalse(MathUtils.equalsIncludingNaN(null, new double[] { 1d }));
-        assertTrue(MathUtils.equalsIncludingNaN((double[]) null, (double[]) null));
-
-        assertFalse(MathUtils.equalsIncludingNaN(new double[] { 1d }, new double[0]));
-        assertTrue(MathUtils.equalsIncludingNaN(new double[] { 1d }, new double[] { 1d }));
-        assertTrue(MathUtils.equalsIncludingNaN(new double[] {
+        Assert.assertFalse(MathUtils.equalsIncludingNaN(new double[] { 1d }, null));
+        Assert.assertFalse(MathUtils.equalsIncludingNaN(null, new double[] { 1d }));
+        Assert.assertTrue(MathUtils.equalsIncludingNaN((double[]) null, (double[]) null));
+
+        Assert.assertFalse(MathUtils.equalsIncludingNaN(new double[] { 1d }, new double[0]));
+        Assert.assertTrue(MathUtils.equalsIncludingNaN(new double[] { 1d }, new double[] { 1d }));
+        Assert.assertTrue(MathUtils.equalsIncludingNaN(new double[] {
                     Double.NaN, Double.POSITIVE_INFINITY,
                     Double.NEGATIVE_INFINITY, 1d, 0d
                 }, new double[] {
                     Double.NaN, Double.POSITIVE_INFINITY,
                     Double.NEGATIVE_INFINITY, 1d, 0d
                 }));
-        assertFalse(MathUtils.equalsIncludingNaN(new double[] { Double.POSITIVE_INFINITY },
+        Assert.assertFalse(MathUtils.equalsIncludingNaN(new double[] { Double.POSITIVE_INFINITY },
                                                  new double[] { Double.NEGATIVE_INFINITY }));
-        assertFalse(MathUtils.equalsIncludingNaN(new double[] { 1d },
+        Assert.assertFalse(MathUtils.equalsIncludingNaN(new double[] { 1d },
                                                  new double[] { FastMath.nextAfter(FastMath.nextAfter(1d, 2d), 2d) }));
     }
 
+    @Test
     public void testFactorial() {
         for (int i = 1; i < 21; i++) {
-            assertEquals(i + "! ", factorial(i), MathUtils.factorial(i));
-            assertEquals(i + "! ", factorial(i), MathUtils.factorialDouble(i), Double.MIN_VALUE);
-            assertEquals(i + "! ", FastMath.log(factorial(i)), MathUtils.factorialLog(i), 10E-12);
+            Assert.assertEquals(i + "! ", factorial(i), MathUtils.factorial(i));
+            Assert.assertEquals(i + "! ", factorial(i), MathUtils.factorialDouble(i), Double.MIN_VALUE);
+            Assert.assertEquals(i + "! ", FastMath.log(factorial(i)), MathUtils.factorialLog(i), 10E-12);
         }
 
-        assertEquals("0", 1, MathUtils.factorial(0));
-        assertEquals("0", 1.0d, MathUtils.factorialDouble(0), 1E-14);
-        assertEquals("0", 0.0d, MathUtils.factorialLog(0), 1E-14);
+        Assert.assertEquals("0", 1, MathUtils.factorial(0));
+        Assert.assertEquals("0", 1.0d, MathUtils.factorialDouble(0), 1E-14);
+        Assert.assertEquals("0", 0.0d, MathUtils.factorialLog(0), 1E-14);
     }
 
+    @Test
     public void testFactorialFail() {
         try {
             MathUtils.factorial(-1);
-            fail("expecting MathIllegalArgumentException");
+            Assert.fail("expecting MathIllegalArgumentException");
         } catch (MathIllegalArgumentException ex) {
             // ignored
         }
         try {
             MathUtils.factorialDouble(-1);
-            fail("expecting MathIllegalArgumentException");
+            Assert.fail("expecting MathIllegalArgumentException");
         } catch (MathIllegalArgumentException ex) {
             // ignored
         }
         try {
             MathUtils.factorialLog(-1);
-            fail("expecting MathIllegalArgumentException");
+            Assert.fail("expecting MathIllegalArgumentException");
         } catch (MathIllegalArgumentException ex) {
             // ignored
         }
         try {
             MathUtils.factorial(21);
-            fail("expecting MathArithmeticException");
+            Assert.fail("expecting MathArithmeticException");
         } catch (MathArithmeticException ex) {
             // ignored
         }
-        assertTrue("expecting infinite factorial value", Double.isInfinite(MathUtils.factorialDouble(171)));
+        Assert.assertTrue("expecting infinite factorial value", Double.isInfinite(MathUtils.factorialDouble(171)));
     }
 
+    @Test
     public void testGcd() {
         int a = 30;
         int b = 50;
         int c = 77;
 
-        assertEquals(0, MathUtils.gcd(0, 0));
+        Assert.assertEquals(0, MathUtils.gcd(0, 0));
 
-        assertEquals(b, MathUtils.gcd(0, b));
-        assertEquals(a, MathUtils.gcd(a, 0));
-        assertEquals(b, MathUtils.gcd(0, -b));
-        assertEquals(a, MathUtils.gcd(-a, 0));
-
-        assertEquals(10, MathUtils.gcd(a, b));
-        assertEquals(10, MathUtils.gcd(-a, b));
-        assertEquals(10, MathUtils.gcd(a, -b));
-        assertEquals(10, MathUtils.gcd(-a, -b));
-
-        assertEquals(1, MathUtils.gcd(a, c));
-        assertEquals(1, MathUtils.gcd(-a, c));
-        assertEquals(1, MathUtils.gcd(a, -c));
-        assertEquals(1, MathUtils.gcd(-a, -c));
-
-        assertEquals(3 * (1<<15), MathUtils.gcd(3 * (1<<20), 9 * (1<<15)));
-
-        assertEquals(Integer.MAX_VALUE, MathUtils.gcd(Integer.MAX_VALUE, 0));
-        assertEquals(Integer.MAX_VALUE, MathUtils.gcd(-Integer.MAX_VALUE, 0));
-        assertEquals(1<<30, MathUtils.gcd(1<<30, -Integer.MIN_VALUE));
+        Assert.assertEquals(b, MathUtils.gcd(0, b));
+        Assert.assertEquals(a, MathUtils.gcd(a, 0));
+        Assert.assertEquals(b, MathUtils.gcd(0, -b));
+        Assert.assertEquals(a, MathUtils.gcd(-a, 0));
+
+        Assert.assertEquals(10, MathUtils.gcd(a, b));
+        Assert.assertEquals(10, MathUtils.gcd(-a, b));
+        Assert.assertEquals(10, MathUtils.gcd(a, -b));
+        Assert.assertEquals(10, MathUtils.gcd(-a, -b));
+
+        Assert.assertEquals(1, MathUtils.gcd(a, c));
+        Assert.assertEquals(1, MathUtils.gcd(-a, c));
+        Assert.assertEquals(1, MathUtils.gcd(a, -c));
+        Assert.assertEquals(1, MathUtils.gcd(-a, -c));
+
+        Assert.assertEquals(3 * (1<<15), MathUtils.gcd(3 * (1<<20), 9 * (1<<15)));
+
+        Assert.assertEquals(Integer.MAX_VALUE, MathUtils.gcd(Integer.MAX_VALUE, 0));
+        Assert.assertEquals(Integer.MAX_VALUE, MathUtils.gcd(-Integer.MAX_VALUE, 0));
+        Assert.assertEquals(1<<30, MathUtils.gcd(1<<30, -Integer.MIN_VALUE));
         try {
             // gcd(Integer.MIN_VALUE, 0) > Integer.MAX_VALUE
             MathUtils.gcd(Integer.MIN_VALUE, 0);
-            fail("expecting MathArithmeticException");
+            Assert.fail("expecting MathArithmeticException");
         } catch (MathArithmeticException expected) {
             // expected
         }
         try {
             // gcd(0, Integer.MIN_VALUE) > Integer.MAX_VALUE
             MathUtils.gcd(0, Integer.MIN_VALUE);
-            fail("expecting MathArithmeticException");
+            Assert.fail("expecting MathArithmeticException");
         } catch (MathArithmeticException expected) {
             // expected
         }
         try {
             // gcd(Integer.MIN_VALUE, Integer.MIN_VALUE) > Integer.MAX_VALUE
             MathUtils.gcd(Integer.MIN_VALUE, Integer.MIN_VALUE);
-            fail("expecting MathArithmeticException");
+            Assert.fail("expecting MathArithmeticException");
         } catch (MathArithmeticException expected) {
             // expected
         }
     }
 
+    @Test
     public void  testGcdLong(){
         long a = 30;
         long b = 50;
         long c = 77;
 
-        assertEquals(0, MathUtils.gcd(0L, 0));
+        Assert.assertEquals(0, MathUtils.gcd(0L, 0));
 
-        assertEquals(b, MathUtils.gcd(0, b));
-        assertEquals(a, MathUtils.gcd(a, 0));
-        assertEquals(b, MathUtils.gcd(0, -b));
-        assertEquals(a, MathUtils.gcd(-a, 0));
-
-        assertEquals(10, MathUtils.gcd(a, b));
-        assertEquals(10, MathUtils.gcd(-a, b));
-        assertEquals(10, MathUtils.gcd(a, -b));
-        assertEquals(10, MathUtils.gcd(-a, -b));
-
-        assertEquals(1, MathUtils.gcd(a, c));
-        assertEquals(1, MathUtils.gcd(-a, c));
-        assertEquals(1, MathUtils.gcd(a, -c));
-        assertEquals(1, MathUtils.gcd(-a, -c));
-
-        assertEquals(3L * (1L<<45), MathUtils.gcd(3L * (1L<<50), 9L * (1L<<45)));
-
-        assertEquals(1L<<45, MathUtils.gcd(1L<<45, Long.MIN_VALUE));
-
-        assertEquals(Long.MAX_VALUE, MathUtils.gcd(Long.MAX_VALUE, 0L));
-        assertEquals(Long.MAX_VALUE, MathUtils.gcd(-Long.MAX_VALUE, 0L));
-        assertEquals(1, MathUtils.gcd(60247241209L, 153092023L));
+        Assert.assertEquals(b, MathUtils.gcd(0, b));
+        Assert.assertEquals(a, MathUtils.gcd(a, 0));
+        Assert.assertEquals(b, MathUtils.gcd(0, -b));
+        Assert.assertEquals(a, MathUtils.gcd(-a, 0));
+
+        Assert.assertEquals(10, MathUtils.gcd(a, b));
+        Assert.assertEquals(10, MathUtils.gcd(-a, b));
+        Assert.assertEquals(10, MathUtils.gcd(a, -b));
+        Assert.assertEquals(10, MathUtils.gcd(-a, -b));
+
+        Assert.assertEquals(1, MathUtils.gcd(a, c));
+        Assert.assertEquals(1, MathUtils.gcd(-a, c));
+        Assert.assertEquals(1, MathUtils.gcd(a, -c));
+        Assert.assertEquals(1, MathUtils.gcd(-a, -c));
+
+        Assert.assertEquals(3L * (1L<<45), MathUtils.gcd(3L * (1L<<50), 9L * (1L<<45)));
+
+        Assert.assertEquals(1L<<45, MathUtils.gcd(1L<<45, Long.MIN_VALUE));
+
+        Assert.assertEquals(Long.MAX_VALUE, MathUtils.gcd(Long.MAX_VALUE, 0L));
+        Assert.assertEquals(Long.MAX_VALUE, MathUtils.gcd(-Long.MAX_VALUE, 0L));
+        Assert.assertEquals(1, MathUtils.gcd(60247241209L, 153092023L));
         try {
             // gcd(Long.MIN_VALUE, 0) > Long.MAX_VALUE
             MathUtils.gcd(Long.MIN_VALUE, 0);
-            fail("expecting MathArithmeticException");
+            Assert.fail("expecting MathArithmeticException");
         } catch (MathArithmeticException expected) {
             // expected
         }
         try {
             // gcd(0, Long.MIN_VALUE) > Long.MAX_VALUE
             MathUtils.gcd(0, Long.MIN_VALUE);
-            fail("expecting MathArithmeticException");
+            Assert.fail("expecting MathArithmeticException");
         } catch (MathArithmeticException expected) {
             // expected
         }
         try {
             // gcd(Long.MIN_VALUE, Long.MIN_VALUE) > Long.MAX_VALUE
             MathUtils.gcd(Long.MIN_VALUE, Long.MIN_VALUE);
-            fail("expecting MathArithmeticException");
+            Assert.fail("expecting MathArithmeticException");
         } catch (MathArithmeticException expected) {
             // expected
         }
     }
 
+    @Test
     public void testGcdConsistency() {
         int[] primeList = {19, 23, 53, 67, 73, 79, 101, 103, 111, 131};
         ArrayList<Integer> primes = new ArrayList<Integer>();
@@ -692,13 +712,14 @@ public final class MathUtilsTest extends
             int i1 = p1 * p2 * p3;
             int i2 = p1 * p2 * p4;
             int gcd = p1 * p2;
-            assertEquals(gcd, MathUtils.gcd(i1, i2));
+            Assert.assertEquals(gcd, MathUtils.gcd(i1, i2));
             long l1 = i1;
             long l2 = i2;
-            assertEquals(gcd, MathUtils.gcd(l1, l2));
+            Assert.assertEquals(gcd, MathUtils.gcd(l1, l2));
         }
     }
 
+    @Test
     public void testHash() {
         double[] testArray = {
             Double.NaN,
@@ -713,19 +734,20 @@ public final class MathUtilsTest extends
         for (int i = 0; i < testArray.length; i++) {
             for (int j = 0; j < testArray.length; j++) {
                 if (i == j) {
-                    assertEquals(MathUtils.hash(testArray[i]), MathUtils.hash(testArray[j]));
-                    assertEquals(MathUtils.hash(testArray[j]), MathUtils.hash(testArray[i]));
+                    Assert.assertEquals(MathUtils.hash(testArray[i]), MathUtils.hash(testArray[j]));
+                    Assert.assertEquals(MathUtils.hash(testArray[j]), MathUtils.hash(testArray[i]));
                 } else {
-                    assertTrue(MathUtils.hash(testArray[i]) != MathUtils.hash(testArray[j]));
-                    assertTrue(MathUtils.hash(testArray[j]) != MathUtils.hash(testArray[i]));
+                    Assert.assertTrue(MathUtils.hash(testArray[i]) != MathUtils.hash(testArray[j]));
+                    Assert.assertTrue(MathUtils.hash(testArray[j]) != MathUtils.hash(testArray[i]));
                 }
             }
         }
     }
 
+    @Test
     public void testArrayHash() {
-        assertEquals(0, MathUtils.hash((double[]) null));
-        assertEquals(MathUtils.hash(new double[] {
+        Assert.assertEquals(0, MathUtils.hash((double[]) null));
+        Assert.assertEquals(MathUtils.hash(new double[] {
                                       Double.NaN, Double.POSITIVE_INFINITY,
                                       Double.NEGATIVE_INFINITY, 1d, 0d
                                     }),
@@ -733,15 +755,16 @@ public final class MathUtilsTest extends
                                       Double.NaN, Double.POSITIVE_INFINITY,
                                       Double.NEGATIVE_INFINITY, 1d, 0d
                                     }));
-        assertFalse(MathUtils.hash(new double[] { 1d }) ==
+        Assert.assertFalse(MathUtils.hash(new double[] { 1d }) ==
                     MathUtils.hash(new double[] { FastMath.nextAfter(1d, 2d) }));
-        assertFalse(MathUtils.hash(new double[] { 1d }) ==
+        Assert.assertFalse(MathUtils.hash(new double[] { 1d }) ==
                     MathUtils.hash(new double[] { 1d, 1d }));
     }
 
     /**
      * Make sure that permuted arrays do not hash to the same value.
      */
+    @Test
     public void testPermutedArrayHash() {
         double[] original = new double[10];
         double[] permuted = new double[10];
@@ -765,74 +788,81 @@ public final class MathUtilsTest extends
         } while (isIdentity);
 
         // Verify that permuted array has different hash
-        assertFalse(MathUtils.hash(original) == MathUtils.hash(permuted));
+        Assert.assertFalse(MathUtils.hash(original) == MathUtils.hash(permuted));
     }
 
+    @Test
     public void testIndicatorByte() {
-        assertEquals((byte)1, MathUtils.indicator((byte)2));
-        assertEquals((byte)1, MathUtils.indicator((byte)0));
-        assertEquals((byte)(-1), MathUtils.indicator((byte)(-2)));
+        Assert.assertEquals((byte)1, MathUtils.indicator((byte)2));
+        Assert.assertEquals((byte)1, MathUtils.indicator((byte)0));
+        Assert.assertEquals((byte)(-1), MathUtils.indicator((byte)(-2)));
     }
 
+    @Test
     public void testIndicatorDouble() {
         double delta = 0.0;
-        assertEquals(1.0, MathUtils.indicator(2.0), delta);
-        assertEquals(1.0, MathUtils.indicator(0.0), delta);
-        assertEquals(-1.0, MathUtils.indicator(-2.0), delta);
-        assertEquals(Double.NaN, MathUtils.indicator(Double.NaN));
+        Assert.assertEquals(1.0, MathUtils.indicator(2.0), delta);
+        Assert.assertEquals(1.0, MathUtils.indicator(0.0), delta);
+        Assert.assertEquals(-1.0, MathUtils.indicator(-2.0), delta);
+        Assert.assertTrue(Double.isNaN(MathUtils.indicator(Double.NaN)));
     }
 
+    @Test
     public void testIndicatorFloat() {
         float delta = 0.0F;
-        assertEquals(1.0F, MathUtils.indicator(2.0F), delta);
-        assertEquals(1.0F, MathUtils.indicator(0.0F), delta);
-        assertEquals(-1.0F, MathUtils.indicator(-2.0F), delta);
+        Assert.assertEquals(1.0F, MathUtils.indicator(2.0F), delta);
+        Assert.assertEquals(1.0F, MathUtils.indicator(0.0F), delta);
+        Assert.assertEquals(-1.0F, MathUtils.indicator(-2.0F), delta);
     }
 
+    @Test
     public void testIndicatorInt() {
-        assertEquals(1, MathUtils.indicator((2)));
-        assertEquals(1, MathUtils.indicator((0)));
-        assertEquals((-1), MathUtils.indicator((-2)));
+        Assert.assertEquals(1, MathUtils.indicator((2)));
+        Assert.assertEquals(1, MathUtils.indicator((0)));
+        Assert.assertEquals((-1), MathUtils.indicator((-2)));
     }
 
+    @Test
     public void testIndicatorLong() {
-        assertEquals(1L, MathUtils.indicator(2L));
-        assertEquals(1L, MathUtils.indicator(0L));
-        assertEquals(-1L, MathUtils.indicator(-2L));
+        Assert.assertEquals(1L, MathUtils.indicator(2L));
+        Assert.assertEquals(1L, MathUtils.indicator(0L));
+        Assert.assertEquals(-1L, MathUtils.indicator(-2L));
     }
 
+    @Test
     public void testIndicatorShort() {
-        assertEquals((short)1, MathUtils.indicator((short)2));
-        assertEquals((short)1, MathUtils.indicator((short)0));
-        assertEquals((short)(-1), MathUtils.indicator((short)(-2)));
+        Assert.assertEquals((short)1, MathUtils.indicator((short)2));
+        Assert.assertEquals((short)1, MathUtils.indicator((short)0));
+        Assert.assertEquals((short)(-1), MathUtils.indicator((short)(-2)));
     }
 
+    @Test
     public void testLcm() {
         int a = 30;
         int b = 50;
         int c = 77;
 
-        assertEquals(0, MathUtils.lcm(0, b));
-        assertEquals(0, MathUtils.lcm(a, 0));
-        assertEquals(b, MathUtils.lcm(1, b));
-        assertEquals(a, MathUtils.lcm(a, 1));
-        assertEquals(150, MathUtils.lcm(a, b));
-        assertEquals(150, MathUtils.lcm(-a, b));
-        assertEquals(150, MathUtils.lcm(a, -b));
-        assertEquals(150, MathUtils.lcm(-a, -b));
-        assertEquals(2310, MathUtils.lcm(a, c));
+        Assert.assertEquals(0, MathUtils.lcm(0, b));
+        Assert.assertEquals(0, MathUtils.lcm(a, 0));
+        Assert.assertEquals(b, MathUtils.lcm(1, b));
+        Assert.assertEquals(a, MathUtils.lcm(a, 1));
+        Assert.assertEquals(150, MathUtils.lcm(a, b));
+        Assert.assertEquals(150, MathUtils.lcm(-a, b));
+        Assert.assertEquals(150, MathUtils.lcm(a, -b));
+        Assert.assertEquals(150, MathUtils.lcm(-a, -b));
+        Assert.assertEquals(2310, MathUtils.lcm(a, c));
 
         // Assert that no intermediate value overflows:
         // The naive implementation of lcm(a,b) would be (a*b)/gcd(a,b)
-        assertEquals((1<<20)*15, MathUtils.lcm((1<<20)*3, (1<<20)*5));
+        Assert.assertEquals((1<<20)*15, MathUtils.lcm((1<<20)*3, (1<<20)*5));
 
         // Special case
-        assertEquals(0, MathUtils.lcm(0, 0));
+        Assert.assertEquals(0, MathUtils.lcm(0, 0));
 
         try {
             // lcm == abs(MIN_VALUE) cannot be represented as a nonnegative int
             MathUtils.lcm(Integer.MIN_VALUE, 1);
-            fail("Expecting MathArithmeticException");
+            Assert.fail("Expecting MathArithmeticException");
         } catch (MathArithmeticException expected) {
             // expected
         }
@@ -840,47 +870,48 @@ public final class MathUtilsTest extends
         try {
             // lcm == abs(MIN_VALUE) cannot be represented as a nonnegative int
             MathUtils.lcm(Integer.MIN_VALUE, 1<<20);
-            fail("Expecting MathArithmeticException");
+            Assert.fail("Expecting MathArithmeticException");
         } catch (MathArithmeticException expected) {
             // expected
         }
 
         try {
             MathUtils.lcm(Integer.MAX_VALUE, Integer.MAX_VALUE - 1);
-            fail("Expecting MathArithmeticException");
+            Assert.fail("Expecting MathArithmeticException");
         } catch (MathArithmeticException expected) {
             // expected
         }
     }
 
+    @Test
     public void testLcmLong() {
         long a = 30;
         long b = 50;
         long c = 77;
 
-        assertEquals(0, MathUtils.lcm(0, b));
-        assertEquals(0, MathUtils.lcm(a, 0));
-        assertEquals(b, MathUtils.lcm(1, b));
-        assertEquals(a, MathUtils.lcm(a, 1));
-        assertEquals(150, MathUtils.lcm(a, b));
-        assertEquals(150, MathUtils.lcm(-a, b));
-        assertEquals(150, MathUtils.lcm(a, -b));
-        assertEquals(150, MathUtils.lcm(-a, -b));
-        assertEquals(2310, MathUtils.lcm(a, c));
+        Assert.assertEquals(0, MathUtils.lcm(0, b));
+        Assert.assertEquals(0, MathUtils.lcm(a, 0));
+        Assert.assertEquals(b, MathUtils.lcm(1, b));
+        Assert.assertEquals(a, MathUtils.lcm(a, 1));
+        Assert.assertEquals(150, MathUtils.lcm(a, b));
+        Assert.assertEquals(150, MathUtils.lcm(-a, b));
+        Assert.assertEquals(150, MathUtils.lcm(a, -b));
+        Assert.assertEquals(150, MathUtils.lcm(-a, -b));
+        Assert.assertEquals(2310, MathUtils.lcm(a, c));
 
-        assertEquals(Long.MAX_VALUE, MathUtils.lcm(60247241209L, 153092023L));
+        Assert.assertEquals(Long.MAX_VALUE, MathUtils.lcm(60247241209L, 153092023L));
 
         // Assert that no intermediate value overflows:
         // The naive implementation of lcm(a,b) would be (a*b)/gcd(a,b)
-        assertEquals((1L<<50)*15, MathUtils.lcm((1L<<45)*3, (1L<<50)*5));
+        Assert.assertEquals((1L<<50)*15, MathUtils.lcm((1L<<45)*3, (1L<<50)*5));
 
         // Special case
-        assertEquals(0L, MathUtils.lcm(0L, 0L));
+        Assert.assertEquals(0L, MathUtils.lcm(0L, 0L));
 
         try {
             // lcm == abs(MIN_VALUE) cannot be represented as a nonnegative int
             MathUtils.lcm(Long.MIN_VALUE, 1);
-            fail("Expecting MathArithmeticException");
+            Assert.fail("Expecting MathArithmeticException");
         } catch (MathArithmeticException expected) {
             // expected
         }
@@ -888,60 +919,63 @@ public final class MathUtilsTest extends
         try {
             // lcm == abs(MIN_VALUE) cannot be represented as a nonnegative int
             MathUtils.lcm(Long.MIN_VALUE, 1<<20);
-            fail("Expecting MathArithmeticException");
+            Assert.fail("Expecting MathArithmeticException");
         } catch (MathArithmeticException expected) {
             // expected
         }
 
-        assertEquals((long) Integer.MAX_VALUE * (Integer.MAX_VALUE - 1),
+        Assert.assertEquals((long) Integer.MAX_VALUE * (Integer.MAX_VALUE - 1),
             MathUtils.lcm((long)Integer.MAX_VALUE, Integer.MAX_VALUE - 1));
         try {
             MathUtils.lcm(Long.MAX_VALUE, Long.MAX_VALUE - 1);
-            fail("Expecting MathArithmeticException");
+            Assert.fail("Expecting MathArithmeticException");
         } catch (MathArithmeticException expected) {
             // expected
         }
     }
 
+    @Test
     public void testLog() {
-        assertEquals(2.0, MathUtils.log(2, 4), 0);
-        assertEquals(3.0, MathUtils.log(2, 8), 0);
-        assertTrue(Double.isNaN(MathUtils.log(-1, 1)));
-        assertTrue(Double.isNaN(MathUtils.log(1, -1)));
-        assertTrue(Double.isNaN(MathUtils.log(0, 0)));
-        assertEquals(0, MathUtils.log(0, 10), 0);
-        assertEquals(Double.NEGATIVE_INFINITY, MathUtils.log(10, 0), 0);
+        Assert.assertEquals(2.0, MathUtils.log(2, 4), 0);
+        Assert.assertEquals(3.0, MathUtils.log(2, 8), 0);
+        Assert.assertTrue(Double.isNaN(MathUtils.log(-1, 1)));
+        Assert.assertTrue(Double.isNaN(MathUtils.log(1, -1)));
+        Assert.assertTrue(Double.isNaN(MathUtils.log(0, 0)));
+        Assert.assertEquals(0, MathUtils.log(0, 10), 0);
+        Assert.assertEquals(Double.NEGATIVE_INFINITY, MathUtils.log(10, 0), 0);
     }
 
+    @Test
     public void testMulAndCheck() {
         int big = Integer.MAX_VALUE;
         int bigNeg = Integer.MIN_VALUE;
-        assertEquals(big, MathUtils.mulAndCheck(big, 1));
+        Assert.assertEquals(big, MathUtils.mulAndCheck(big, 1));
         try {
             MathUtils.mulAndCheck(big, 2);
-            fail("Expecting MathArithmeticException");
+            Assert.fail("Expecting MathArithmeticException");
         } catch (MathArithmeticException ex) {
         }
         try {
             MathUtils.mulAndCheck(bigNeg, 2);
-            fail("Expecting MathArithmeticException");
+            Assert.fail("Expecting MathArithmeticException");
         } catch (MathArithmeticException ex) {
         }
     }
 
+    @Test
     public void testMulAndCheckLong() {
         long max = Long.MAX_VALUE;
         long min = Long.MIN_VALUE;
-        assertEquals(max, MathUtils.mulAndCheck(max, 1L));
-        assertEquals(min, MathUtils.mulAndCheck(min, 1L));
-        assertEquals(0L, MathUtils.mulAndCheck(max, 0L));
-        assertEquals(0L, MathUtils.mulAndCheck(min, 0L));
-        assertEquals(max, MathUtils.mulAndCheck(1L, max));
-        assertEquals(min, MathUtils.mulAndCheck(1L, min));
-        assertEquals(0L, MathUtils.mulAndCheck(0L, max));
-        assertEquals(0L, MathUtils.mulAndCheck(0L, min));
-        assertEquals(1L, MathUtils.mulAndCheck(-1L, -1L));
-        assertEquals(min, MathUtils.mulAndCheck(min / 2, 2));
+        Assert.assertEquals(max, MathUtils.mulAndCheck(max, 1L));
+        Assert.assertEquals(min, MathUtils.mulAndCheck(min, 1L));
+        Assert.assertEquals(0L, MathUtils.mulAndCheck(max, 0L));
+        Assert.assertEquals(0L, MathUtils.mulAndCheck(min, 0L));
+        Assert.assertEquals(max, MathUtils.mulAndCheck(1L, max));
+        Assert.assertEquals(min, MathUtils.mulAndCheck(1L, min));
+        Assert.assertEquals(0L, MathUtils.mulAndCheck(0L, max));
+        Assert.assertEquals(0L, MathUtils.mulAndCheck(0L, min));
+        Assert.assertEquals(1L, MathUtils.mulAndCheck(-1L, -1L));
+        Assert.assertEquals(min, MathUtils.mulAndCheck(min / 2, 2));
         testMulAndCheckLongFailure(max, 2L);
         testMulAndCheckLongFailure(2L, max);
         testMulAndCheckLongFailure(min, 2L);
@@ -953,24 +987,26 @@ public final class MathUtilsTest extends
     private void testMulAndCheckLongFailure(long a, long b) {
         try {
             MathUtils.mulAndCheck(a, b);
-            fail("Expecting MathArithmeticException");
+            Assert.fail("Expecting MathArithmeticException");
         } catch (MathArithmeticException ex) {
             // success
         }
     }
 
+    @Test
     public void testNormalizeAngle() {
         for (double a = -15.0; a <= 15.0; a += 0.1) {
             for (double b = -15.0; b <= 15.0; b += 0.2) {
                 double c = MathUtils.normalizeAngle(a, b);
-                assertTrue((b - FastMath.PI) <= c);
-                assertTrue(c <= (b + FastMath.PI));
+                Assert.assertTrue((b - FastMath.PI) <= c);
+                Assert.assertTrue(c <= (b + FastMath.PI));
                 double twoK = FastMath.rint((a - c) / FastMath.PI);
-                assertEquals(c, a - twoK * FastMath.PI, 1.0e-14);
+                Assert.assertEquals(c, a - twoK * FastMath.PI, 1.0e-14);
             }
         }
     }
 
+    @Test
     public void testNormalizeArray() {
         double[] testValues1 = new double[] {1, 1, 2};
         TestUtils.assertEquals(
@@ -995,322 +1031,335 @@ public final class MathUtilsTest extends
         double[] zeroSum = new double[] {-1, 1};
         try {
             MathUtils.normalizeArray(zeroSum, 1);
-            fail("expecting MathArithmeticException");
+            Assert.fail("expecting MathArithmeticException");
         } catch (MathArithmeticException ex) {}
 
         // Infinite elements -> MathArithmeticException
         double[] hasInf = new double[] {1, 2, 1, Double.NEGATIVE_INFINITY};
         try {
             MathUtils.normalizeArray(hasInf, 1);
-            fail("expecting MathIllegalArgumentException");
+            Assert.fail("expecting MathIllegalArgumentException");
         } catch (MathIllegalArgumentException ex) {}
 
         // Infinite target -> MathIllegalArgumentException
         try {
             MathUtils.normalizeArray(testValues1, Double.POSITIVE_INFINITY);
-            fail("expecting MathIllegalArgumentException");
+            Assert.fail("expecting MathIllegalArgumentException");
         } catch (MathIllegalArgumentException ex) {}
 
         // NaN target -> MathIllegalArgumentException
         try {
             MathUtils.normalizeArray(testValues1, Double.NaN);
-            fail("expecting MathIllegalArgumentException");
+            Assert.fail("expecting MathIllegalArgumentException");
         } catch (MathIllegalArgumentException ex) {}
 
     }
 
+    @Test
     public void testRoundDouble() {
         double x = 1.234567890;
-        assertEquals(1.23, MathUtils.round(x, 2), 0.0);
-        assertEquals(1.235, MathUtils.round(x, 3), 0.0);
-        assertEquals(1.2346, MathUtils.round(x, 4), 0.0);
+        Assert.assertEquals(1.23, MathUtils.round(x, 2), 0.0);
+        Assert.assertEquals(1.235, MathUtils.round(x, 3), 0.0);
+        Assert.assertEquals(1.2346, MathUtils.round(x, 4), 0.0);
 
         // JIRA MATH-151
-        assertEquals(39.25, MathUtils.round(39.245, 2), 0.0);
-        assertEquals(39.24, MathUtils.round(39.245, 2, BigDecimal.ROUND_DOWN), 0.0);
+        Assert.assertEquals(39.25, MathUtils.round(39.245, 2), 0.0);
+        Assert.assertEquals(39.24, MathUtils.round(39.245, 2, BigDecimal.ROUND_DOWN), 0.0);
         double xx = 39.0;
         xx = xx + 245d / 1000d;
-        assertEquals(39.25, MathUtils.round(xx, 2), 0.0);
+        Assert.assertEquals(39.25, MathUtils.round(xx, 2), 0.0);
 
         // BZ 35904
-        assertEquals(30.1d, MathUtils.round(30.095d, 2), 0.0d);
-        assertEquals(30.1d, MathUtils.round(30.095d, 1), 0.0d);
-        assertEquals(33.1d, MathUtils.round(33.095d, 1), 0.0d);
-        assertEquals(33.1d, MathUtils.round(33.095d, 2), 0.0d);
-        assertEquals(50.09d, MathUtils.round(50.085d, 2), 0.0d);
-        assertEquals(50.19d, MathUtils.round(50.185d, 2), 0.0d);
-        assertEquals(50.01d, MathUtils.round(50.005d, 2), 0.0d);
-        assertEquals(30.01d, MathUtils.round(30.005d, 2), 0.0d);
-        assertEquals(30.65d, MathUtils.round(30.645d, 2), 0.0d);
-
-        assertEquals(1.24, MathUtils.round(x, 2, BigDecimal.ROUND_CEILING), 0.0);
-        assertEquals(1.235, MathUtils.round(x, 3, BigDecimal.ROUND_CEILING), 0.0);
-        assertEquals(1.2346, MathUtils.round(x, 4, BigDecimal.ROUND_CEILING), 0.0);
-        assertEquals(-1.23, MathUtils.round(-x, 2, BigDecimal.ROUND_CEILING), 0.0);
-        assertEquals(-1.234, MathUtils.round(-x, 3, BigDecimal.ROUND_CEILING), 0.0);
-        assertEquals(-1.2345, MathUtils.round(-x, 4, BigDecimal.ROUND_CEILING), 0.0);
-
-        assertEquals(1.23, MathUtils.round(x, 2, BigDecimal.ROUND_DOWN), 0.0);
-        assertEquals(1.234, MathUtils.round(x, 3, BigDecimal.ROUND_DOWN), 0.0);
-        assertEquals(1.2345, MathUtils.round(x, 4, BigDecimal.ROUND_DOWN), 0.0);
-        assertEquals(-1.23, MathUtils.round(-x, 2, BigDecimal.ROUND_DOWN), 0.0);
-        assertEquals(-1.234, MathUtils.round(-x, 3, BigDecimal.ROUND_DOWN), 0.0);
-        assertEquals(-1.2345, MathUtils.round(-x, 4, BigDecimal.ROUND_DOWN), 0.0);
-
-        assertEquals(1.23, MathUtils.round(x, 2, BigDecimal.ROUND_FLOOR), 0.0);
-        assertEquals(1.234, MathUtils.round(x, 3, BigDecimal.ROUND_FLOOR), 0.0);
-        assertEquals(1.2345, MathUtils.round(x, 4, BigDecimal.ROUND_FLOOR), 0.0);
-        assertEquals(-1.24, MathUtils.round(-x, 2, BigDecimal.ROUND_FLOOR), 0.0);
-        assertEquals(-1.235, MathUtils.round(-x, 3, BigDecimal.ROUND_FLOOR), 0.0);
-        assertEquals(-1.2346, MathUtils.round(-x, 4, BigDecimal.ROUND_FLOOR), 0.0);
-
-        assertEquals(1.23, MathUtils.round(x, 2, BigDecimal.ROUND_HALF_DOWN), 0.0);
-        assertEquals(1.235, MathUtils.round(x, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
-        assertEquals(1.2346, MathUtils.round(x, 4, BigDecimal.ROUND_HALF_DOWN), 0.0);
-        assertEquals(-1.23, MathUtils.round(-x, 2, BigDecimal.ROUND_HALF_DOWN), 0.0);
-        assertEquals(-1.235, MathUtils.round(-x, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
-        assertEquals(-1.2346, MathUtils.round(-x, 4, BigDecimal.ROUND_HALF_DOWN), 0.0);
-        assertEquals(1.234, MathUtils.round(1.2345, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
-        assertEquals(-1.234, MathUtils.round(-1.2345, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
-
-        assertEquals(1.23, MathUtils.round(x, 2, BigDecimal.ROUND_HALF_EVEN), 0.0);
-        assertEquals(1.235, MathUtils.round(x, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
-        assertEquals(1.2346, MathUtils.round(x, 4, BigDecimal.ROUND_HALF_EVEN), 0.0);
-        assertEquals(-1.23, MathUtils.round(-x, 2, BigDecimal.ROUND_HALF_EVEN), 0.0);
-        assertEquals(-1.235, MathUtils.round(-x, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
-        assertEquals(-1.2346, MathUtils.round(-x, 4, BigDecimal.ROUND_HALF_EVEN), 0.0);
-        assertEquals(1.234, MathUtils.round(1.2345, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
-        assertEquals(-1.234, MathUtils.round(-1.2345, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
-        assertEquals(1.236, MathUtils.round(1.2355, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
-        assertEquals(-1.236, MathUtils.round(-1.2355, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
-
-        assertEquals(1.23, MathUtils.round(x, 2, BigDecimal.ROUND_HALF_UP), 0.0);
-        assertEquals(1.235, MathUtils.round(x, 3, BigDecimal.ROUND_HALF_UP), 0.0);
-        assertEquals(1.2346, MathUtils.round(x, 4, BigDecimal.ROUND_HALF_UP), 0.0);
-        assertEquals(-1.23, MathUtils.round(-x, 2, BigDecimal.ROUND_HALF_UP), 0.0);
-        assertEquals(-1.235, MathUtils.round(-x, 3, BigDecimal.ROUND_HALF_UP), 0.0);
-        assertEquals(-1.2346, MathUtils.round(-x, 4, BigDecimal.ROUND_HALF_UP), 0.0);
-        assertEquals(1.235, MathUtils.round(1.2345, 3, BigDecimal.ROUND_HALF_UP), 0.0);
-        assertEquals(-1.235, MathUtils.round(-1.2345, 3, BigDecimal.ROUND_HALF_UP), 0.0);
+        Assert.assertEquals(30.1d, MathUtils.round(30.095d, 2), 0.0d);
+        Assert.assertEquals(30.1d, MathUtils.round(30.095d, 1), 0.0d);
+        Assert.assertEquals(33.1d, MathUtils.round(33.095d, 1), 0.0d);
+        Assert.assertEquals(33.1d, MathUtils.round(33.095d, 2), 0.0d);
+        Assert.assertEquals(50.09d, MathUtils.round(50.085d, 2), 0.0d);
+        Assert.assertEquals(50.19d, MathUtils.round(50.185d, 2), 0.0d);
+        Assert.assertEquals(50.01d, MathUtils.round(50.005d, 2), 0.0d);
+        Assert.assertEquals(30.01d, MathUtils.round(30.005d, 2), 0.0d);
+        Assert.assertEquals(30.65d, MathUtils.round(30.645d, 2), 0.0d);
+
+        Assert.assertEquals(1.24, MathUtils.round(x, 2, BigDecimal.ROUND_CEILING), 0.0);
+        Assert.assertEquals(1.235, MathUtils.round(x, 3, BigDecimal.ROUND_CEILING), 0.0);
+        Assert.assertEquals(1.2346, MathUtils.round(x, 4, BigDecimal.ROUND_CEILING), 0.0);
+        Assert.assertEquals(-1.23, MathUtils.round(-x, 2, BigDecimal.ROUND_CEILING), 0.0);
+        Assert.assertEquals(-1.234, MathUtils.round(-x, 3, BigDecimal.ROUND_CEILING), 0.0);
+        Assert.assertEquals(-1.2345, MathUtils.round(-x, 4, BigDecimal.ROUND_CEILING), 0.0);
+
+        Assert.assertEquals(1.23, MathUtils.round(x, 2, BigDecimal.ROUND_DOWN), 0.0);
+        Assert.assertEquals(1.234, MathUtils.round(x, 3, BigDecimal.ROUND_DOWN), 0.0);
+        Assert.assertEquals(1.2345, MathUtils.round(x, 4, BigDecimal.ROUND_DOWN), 0.0);
+        Assert.assertEquals(-1.23, MathUtils.round(-x, 2, BigDecimal.ROUND_DOWN), 0.0);
+        Assert.assertEquals(-1.234, MathUtils.round(-x, 3, BigDecimal.ROUND_DOWN), 0.0);
+        Assert.assertEquals(-1.2345, MathUtils.round(-x, 4, BigDecimal.ROUND_DOWN), 0.0);
+
+        Assert.assertEquals(1.23, MathUtils.round(x, 2, BigDecimal.ROUND_FLOOR), 0.0);
+        Assert.assertEquals(1.234, MathUtils.round(x, 3, BigDecimal.ROUND_FLOOR), 0.0);
+        Assert.assertEquals(1.2345, MathUtils.round(x, 4, BigDecimal.ROUND_FLOOR), 0.0);
+        Assert.assertEquals(-1.24, MathUtils.round(-x, 2, BigDecimal.ROUND_FLOOR), 0.0);
+        Assert.assertEquals(-1.235, MathUtils.round(-x, 3, BigDecimal.ROUND_FLOOR), 0.0);
+        Assert.assertEquals(-1.2346, MathUtils.round(-x, 4, BigDecimal.ROUND_FLOOR), 0.0);
+
+        Assert.assertEquals(1.23, MathUtils.round(x, 2, BigDecimal.ROUND_HALF_DOWN), 0.0);
+        Assert.assertEquals(1.235, MathUtils.round(x, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
+        Assert.assertEquals(1.2346, MathUtils.round(x, 4, BigDecimal.ROUND_HALF_DOWN), 0.0);
+        Assert.assertEquals(-1.23, MathUtils.round(-x, 2, BigDecimal.ROUND_HALF_DOWN), 0.0);
+        Assert.assertEquals(-1.235, MathUtils.round(-x, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
+        Assert.assertEquals(-1.2346, MathUtils.round(-x, 4, BigDecimal.ROUND_HALF_DOWN), 0.0);
+        Assert.assertEquals(1.234, MathUtils.round(1.2345, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
+        Assert.assertEquals(-1.234, MathUtils.round(-1.2345, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
+
+        Assert.assertEquals(1.23, MathUtils.round(x, 2, BigDecimal.ROUND_HALF_EVEN), 0.0);
+        Assert.assertEquals(1.235, MathUtils.round(x, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
+        Assert.assertEquals(1.2346, MathUtils.round(x, 4, BigDecimal.ROUND_HALF_EVEN), 0.0);
+        Assert.assertEquals(-1.23, MathUtils.round(-x, 2, BigDecimal.ROUND_HALF_EVEN), 0.0);
+        Assert.assertEquals(-1.235, MathUtils.round(-x, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
+        Assert.assertEquals(-1.2346, MathUtils.round(-x, 4, BigDecimal.ROUND_HALF_EVEN), 0.0);
+        Assert.assertEquals(1.234, MathUtils.round(1.2345, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
+        Assert.assertEquals(-1.234, MathUtils.round(-1.2345, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
+        Assert.assertEquals(1.236, MathUtils.round(1.2355, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
+        Assert.assertEquals(-1.236, MathUtils.round(-1.2355, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
+
+        Assert.assertEquals(1.23, MathUtils.round(x, 2, BigDecimal.ROUND_HALF_UP), 0.0);
+        Assert.assertEquals(1.235, MathUtils.round(x, 3, BigDecimal.ROUND_HALF_UP), 0.0);
+        Assert.assertEquals(1.2346, MathUtils.round(x, 4, BigDecimal.ROUND_HALF_UP), 0.0);
+        Assert.assertEquals(-1.23, MathUtils.round(-x, 2, BigDecimal.ROUND_HALF_UP), 0.0);
+        Assert.assertEquals(-1.235, MathUtils.round(-x, 3, BigDecimal.ROUND_HALF_UP), 0.0);
+        Assert.assertEquals(-1.2346, MathUtils.round(-x, 4, BigDecimal.ROUND_HALF_UP), 0.0);
+        Assert.assertEquals(1.235, MathUtils.round(1.2345, 3, BigDecimal.ROUND_HALF_UP), 0.0);
+        Assert.assertEquals(-1.235, MathUtils.round(-1.2345, 3, BigDecimal.ROUND_HALF_UP), 0.0);
 
-        assertEquals(-1.23, MathUtils.round(-1.23, 2, BigDecimal.ROUND_UNNECESSARY), 0.0);
-        assertEquals(1.23, MathUtils.round(1.23, 2, BigDecimal.ROUND_UNNECESSARY), 0.0);
+        Assert.assertEquals(-1.23, MathUtils.round(-1.23, 2, BigDecimal.ROUND_UNNECESSARY), 0.0);
+        Assert.assertEquals(1.23, MathUtils.round(1.23, 2, BigDecimal.ROUND_UNNECESSARY), 0.0);
 
         try {
             MathUtils.round(1.234, 2, BigDecimal.ROUND_UNNECESSARY);
-            fail();
+            Assert.fail();
         } catch (MathRuntimeException ex) { // XXX Loosing semantics?
             // success
         }
 
-        assertEquals(1.24, MathUtils.round(x, 2, BigDecimal.ROUND_UP), 0.0);
-        assertEquals(1.235, MathUtils.round(x, 3, BigDecimal.ROUND_UP), 0.0);
-        assertEquals(1.2346, MathUtils.round(x, 4, BigDecimal.ROUND_UP), 0.0);
-        assertEquals(-1.24, MathUtils.round(-x, 2, BigDecimal.ROUND_UP), 0.0);
-        assertEquals(-1.235, MathUtils.round(-x, 3, BigDecimal.ROUND_UP), 0.0);
-        assertEquals(-1.2346, MathUtils.round(-x, 4, BigDecimal.ROUND_UP), 0.0);
+        Assert.assertEquals(1.24, MathUtils.round(x, 2, BigDecimal.ROUND_UP), 0.0);
+        Assert.assertEquals(1.235, MathUtils.round(x, 3, BigDecimal.ROUND_UP), 0.0);
+        Assert.assertEquals(1.2346, MathUtils.round(x, 4, BigDecimal.ROUND_UP), 0.0);
+        Assert.assertEquals(-1.24, MathUtils.round(-x, 2, BigDecimal.ROUND_UP), 0.0);
+        Assert.assertEquals(-1.235, MathUtils.round(-x, 3, BigDecimal.ROUND_UP), 0.0);
+        Assert.assertEquals(-1.2346, MathUtils.round(-x, 4, BigDecimal.ROUND_UP), 0.0);
 
         try {
             MathUtils.round(1.234, 2, 1923);
-            fail();
+            Assert.fail();
         } catch (MathRuntimeException ex) { // XXX Loosing semantics?
             // success
         }
 
         // MATH-151
-        assertEquals(39.25, MathUtils.round(39.245, 2, BigDecimal.ROUND_HALF_UP), 0.0);
+        Assert.assertEquals(39.25, MathUtils.round(39.245, 2, BigDecimal.ROUND_HALF_UP), 0.0);
 
         // special values
         TestUtils.assertEquals(Double.NaN, MathUtils.round(Double.NaN, 2), 0.0);
-        assertEquals(0.0, MathUtils.round(0.0, 2), 0.0);
-        assertEquals(Double.POSITIVE_INFINITY, MathUtils.round(Double.POSITIVE_INFINITY, 2), 0.0);
-        assertEquals(Double.NEGATIVE_INFINITY, MathUtils.round(Double.NEGATIVE_INFINITY, 2), 0.0);
+        Assert.assertEquals(0.0, MathUtils.round(0.0, 2), 0.0);
+        Assert.assertEquals(Double.POSITIVE_INFINITY, MathUtils.round(Double.POSITIVE_INFINITY, 2), 0.0);
+        Assert.assertEquals(Double.NEGATIVE_INFINITY, MathUtils.round(Double.NEGATIVE_INFINITY, 2), 0.0);
     }
 
+    @Test
     public void testRoundFloat() {
         float x = 1.234567890f;
-        assertEquals(1.23f, MathUtils.round(x, 2), 0.0);
-        assertEquals(1.235f, MathUtils.round(x, 3), 0.0);
-        assertEquals(1.2346f, MathUtils.round(x, 4), 0.0);
+        Assert.assertEquals(1.23f, MathUtils.round(x, 2), 0.0);
+        Assert.assertEquals(1.235f, MathUtils.round(x, 3), 0.0);
+        Assert.assertEquals(1.2346f, MathUtils.round(x, 4), 0.0);
 
         // BZ 35904
-        assertEquals(30.1f, MathUtils.round(30.095f, 2), 0.0f);
-        assertEquals(30.1f, MathUtils.round(30.095f, 1), 0.0f);
-        assertEquals(50.09f, MathUtils.round(50.085f, 2), 0.0f);
-        assertEquals(50.19f, MathUtils.round(50.185f, 2), 0.0f);
-        assertEquals(50.01f, MathUtils.round(50.005f, 2), 0.0f);
-        assertEquals(30.01f, MathUtils.round(30.005f, 2), 0.0f);
-        assertEquals(30.65f, MathUtils.round(30.645f, 2), 0.0f);
-
-        assertEquals(1.24f, MathUtils.round(x, 2, BigDecimal.ROUND_CEILING), 0.0);
-        assertEquals(1.235f, MathUtils.round(x, 3, BigDecimal.ROUND_CEILING), 0.0);
-        assertEquals(1.2346f, MathUtils.round(x, 4, BigDecimal.ROUND_CEILING), 0.0);
-        assertEquals(-1.23f, MathUtils.round(-x, 2, BigDecimal.ROUND_CEILING), 0.0);
-        assertEquals(-1.234f, MathUtils.round(-x, 3, BigDecimal.ROUND_CEILING), 0.0);
-        assertEquals(-1.2345f, MathUtils.round(-x, 4, BigDecimal.ROUND_CEILING), 0.0);
-
-        assertEquals(1.23f, MathUtils.round(x, 2, BigDecimal.ROUND_DOWN), 0.0);
-        assertEquals(1.234f, MathUtils.round(x, 3, BigDecimal.ROUND_DOWN), 0.0);
-        assertEquals(1.2345f, MathUtils.round(x, 4, BigDecimal.ROUND_DOWN), 0.0);
-        assertEquals(-1.23f, MathUtils.round(-x, 2, BigDecimal.ROUND_DOWN), 0.0);
-        assertEquals(-1.234f, MathUtils.round(-x, 3, BigDecimal.ROUND_DOWN), 0.0);
-        assertEquals(-1.2345f, MathUtils.round(-x, 4, BigDecimal.ROUND_DOWN), 0.0);
-
-        assertEquals(1.23f, MathUtils.round(x, 2, BigDecimal.ROUND_FLOOR), 0.0);
-        assertEquals(1.234f, MathUtils.round(x, 3, BigDecimal.ROUND_FLOOR), 0.0);
-        assertEquals(1.2345f, MathUtils.round(x, 4, BigDecimal.ROUND_FLOOR), 0.0);
-        assertEquals(-1.24f, MathUtils.round(-x, 2, BigDecimal.ROUND_FLOOR), 0.0);
-        assertEquals(-1.235f, MathUtils.round(-x, 3, BigDecimal.ROUND_FLOOR), 0.0);
-        assertEquals(-1.2346f, MathUtils.round(-x, 4, BigDecimal.ROUND_FLOOR), 0.0);
-
-        assertEquals(1.23f, MathUtils.round(x, 2, BigDecimal.ROUND_HALF_DOWN), 0.0);
-        assertEquals(1.235f, MathUtils.round(x, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
-        assertEquals(1.2346f, MathUtils.round(x, 4, BigDecimal.ROUND_HALF_DOWN), 0.0);
-        assertEquals(-1.23f, MathUtils.round(-x, 2, BigDecimal.ROUND_HALF_DOWN), 0.0);
-        assertEquals(-1.235f, MathUtils.round(-x, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
-        assertEquals(-1.2346f, MathUtils.round(-x, 4, BigDecimal.ROUND_HALF_DOWN), 0.0);
-        assertEquals(1.234f, MathUtils.round(1.2345f, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
-        assertEquals(-1.234f, MathUtils.round(-1.2345f, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
-
-        assertEquals(1.23f, MathUtils.round(x, 2, BigDecimal.ROUND_HALF_EVEN), 0.0);
-        assertEquals(1.235f, MathUtils.round(x, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
-        assertEquals(1.2346f, MathUtils.round(x, 4, BigDecimal.ROUND_HALF_EVEN), 0.0);
-        assertEquals(-1.23f, MathUtils.round(-x, 2, BigDecimal.ROUND_HALF_EVEN), 0.0);
-        assertEquals(-1.235f, MathUtils.round(-x, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
-        assertEquals(-1.2346f, MathUtils.round(-x, 4, BigDecimal.ROUND_HALF_EVEN), 0.0);
-        assertEquals(1.234f, MathUtils.round(1.2345f, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
-        assertEquals(-1.234f, MathUtils.round(-1.2345f, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
-        assertEquals(1.236f, MathUtils.round(1.2355f, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
-        assertEquals(-1.236f, MathUtils.round(-1.2355f, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
-
-        assertEquals(1.23f, MathUtils.round(x, 2, BigDecimal.ROUND_HALF_UP), 0.0);
-        assertEquals(1.235f, MathUtils.round(x, 3, BigDecimal.ROUND_HALF_UP), 0.0);
-        assertEquals(1.2346f, MathUtils.round(x, 4, BigDecimal.ROUND_HALF_UP), 0.0);
-        assertEquals(-1.23f, MathUtils.round(-x, 2, BigDecimal.ROUND_HALF_UP), 0.0);
-        assertEquals(-1.235f, MathUtils.round(-x, 3, BigDecimal.ROUND_HALF_UP), 0.0);
-        assertEquals(-1.2346f, MathUtils.round(-x, 4, BigDecimal.ROUND_HALF_UP), 0.0);
-        assertEquals(1.235f, MathUtils.round(1.2345f, 3, BigDecimal.ROUND_HALF_UP), 0.0);
-        assertEquals(-1.235f, MathUtils.round(-1.2345f, 3, BigDecimal.ROUND_HALF_UP), 0.0);
+        Assert.assertEquals(30.1f, MathUtils.round(30.095f, 2), 0.0f);
+        Assert.assertEquals(30.1f, MathUtils.round(30.095f, 1), 0.0f);
+        Assert.assertEquals(50.09f, MathUtils.round(50.085f, 2), 0.0f);
+        Assert.assertEquals(50.19f, MathUtils.round(50.185f, 2), 0.0f);
+        Assert.assertEquals(50.01f, MathUtils.round(50.005f, 2), 0.0f);
+        Assert.assertEquals(30.01f, MathUtils.round(30.005f, 2), 0.0f);
+        Assert.assertEquals(30.65f, MathUtils.round(30.645f, 2), 0.0f);
+
+        Assert.assertEquals(1.24f, MathUtils.round(x, 2, BigDecimal.ROUND_CEILING), 0.0);
+        Assert.assertEquals(1.235f, MathUtils.round(x, 3, BigDecimal.ROUND_CEILING), 0.0);
+        Assert.assertEquals(1.2346f, MathUtils.round(x, 4, BigDecimal.ROUND_CEILING), 0.0);
+        Assert.assertEquals(-1.23f, MathUtils.round(-x, 2, BigDecimal.ROUND_CEILING), 0.0);
+        Assert.assertEquals(-1.234f, MathUtils.round(-x, 3, BigDecimal.ROUND_CEILING), 0.0);
+        Assert.assertEquals(-1.2345f, MathUtils.round(-x, 4, BigDecimal.ROUND_CEILING), 0.0);
+
+        Assert.assertEquals(1.23f, MathUtils.round(x, 2, BigDecimal.ROUND_DOWN), 0.0);
+        Assert.assertEquals(1.234f, MathUtils.round(x, 3, BigDecimal.ROUND_DOWN), 0.0);
+        Assert.assertEquals(1.2345f, MathUtils.round(x, 4, BigDecimal.ROUND_DOWN), 0.0);
+        Assert.assertEquals(-1.23f, MathUtils.round(-x, 2, BigDecimal.ROUND_DOWN), 0.0);
+        Assert.assertEquals(-1.234f, MathUtils.round(-x, 3, BigDecimal.ROUND_DOWN), 0.0);
+        Assert.assertEquals(-1.2345f, MathUtils.round(-x, 4, BigDecimal.ROUND_DOWN), 0.0);
+
+        Assert.assertEquals(1.23f, MathUtils.round(x, 2, BigDecimal.ROUND_FLOOR), 0.0);
+        Assert.assertEquals(1.234f, MathUtils.round(x, 3, BigDecimal.ROUND_FLOOR), 0.0);
+        Assert.assertEquals(1.2345f, MathUtils.round(x, 4, BigDecimal.ROUND_FLOOR), 0.0);
+        Assert.assertEquals(-1.24f, MathUtils.round(-x, 2, BigDecimal.ROUND_FLOOR), 0.0);
+        Assert.assertEquals(-1.235f, MathUtils.round(-x, 3, BigDecimal.ROUND_FLOOR), 0.0);
+        Assert.assertEquals(-1.2346f, MathUtils.round(-x, 4, BigDecimal.ROUND_FLOOR), 0.0);
+
+        Assert.assertEquals(1.23f, MathUtils.round(x, 2, BigDecimal.ROUND_HALF_DOWN), 0.0);
+        Assert.assertEquals(1.235f, MathUtils.round(x, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
+        Assert.assertEquals(1.2346f, MathUtils.round(x, 4, BigDecimal.ROUND_HALF_DOWN), 0.0);
+        Assert.assertEquals(-1.23f, MathUtils.round(-x, 2, BigDecimal.ROUND_HALF_DOWN), 0.0);
+        Assert.assertEquals(-1.235f, MathUtils.round(-x, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
+        Assert.assertEquals(-1.2346f, MathUtils.round(-x, 4, BigDecimal.ROUND_HALF_DOWN), 0.0);
+        Assert.assertEquals(1.234f, MathUtils.round(1.2345f, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
+        Assert.assertEquals(-1.234f, MathUtils.round(-1.2345f, 3, BigDecimal.ROUND_HALF_DOWN), 0.0);
+
+        Assert.assertEquals(1.23f, MathUtils.round(x, 2, BigDecimal.ROUND_HALF_EVEN), 0.0);
+        Assert.assertEquals(1.235f, MathUtils.round(x, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
+        Assert.assertEquals(1.2346f, MathUtils.round(x, 4, BigDecimal.ROUND_HALF_EVEN), 0.0);
+        Assert.assertEquals(-1.23f, MathUtils.round(-x, 2, BigDecimal.ROUND_HALF_EVEN), 0.0);
+        Assert.assertEquals(-1.235f, MathUtils.round(-x, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
+        Assert.assertEquals(-1.2346f, MathUtils.round(-x, 4, BigDecimal.ROUND_HALF_EVEN), 0.0);
+        Assert.assertEquals(1.234f, MathUtils.round(1.2345f, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
+        Assert.assertEquals(-1.234f, MathUtils.round(-1.2345f, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
+        Assert.assertEquals(1.236f, MathUtils.round(1.2355f, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
+        Assert.assertEquals(-1.236f, MathUtils.round(-1.2355f, 3, BigDecimal.ROUND_HALF_EVEN), 0.0);
+
+        Assert.assertEquals(1.23f, MathUtils.round(x, 2, BigDecimal.ROUND_HALF_UP), 0.0);
+        Assert.assertEquals(1.235f, MathUtils.round(x, 3, BigDecimal.ROUND_HALF_UP), 0.0);
+        Assert.assertEquals(1.2346f, MathUtils.round(x, 4, BigDecimal.ROUND_HALF_UP), 0.0);
+        Assert.assertEquals(-1.23f, MathUtils.round(-x, 2, BigDecimal.ROUND_HALF_UP), 0.0);
+        Assert.assertEquals(-1.235f, MathUtils.round(-x, 3, BigDecimal.ROUND_HALF_UP), 0.0);
+        Assert.assertEquals(-1.2346f, MathUtils.round(-x, 4, BigDecimal.ROUND_HALF_UP), 0.0);
+        Assert.assertEquals(1.235f, MathUtils.round(1.2345f, 3, BigDecimal.ROUND_HALF_UP), 0.0);
+        Assert.assertEquals(-1.235f, MathUtils.round(-1.2345f, 3, BigDecimal.ROUND_HALF_UP), 0.0);
 
-        assertEquals(-1.23f, MathUtils.round(-1.23f, 2, BigDecimal.ROUND_UNNECESSARY), 0.0);
-        assertEquals(1.23f, MathUtils.round(1.23f, 2, BigDecimal.ROUND_UNNECESSARY), 0.0);
+        Assert.assertEquals(-1.23f, MathUtils.round(-1.23f, 2, BigDecimal.ROUND_UNNECESSARY), 0.0);
+        Assert.assertEquals(1.23f, MathUtils.round(1.23f, 2, BigDecimal.ROUND_UNNECESSARY), 0.0);
 
         try {
             MathUtils.round(1.234f, 2, BigDecimal.ROUND_UNNECESSARY);
-            fail();
+            Assert.fail();
         } catch (MathArithmeticException ex) {
             // success
         }
 
-        assertEquals(1.24f, MathUtils.round(x, 2, BigDecimal.ROUND_UP), 0.0);
-        assertEquals(1.235f, MathUtils.round(x, 3, BigDecimal.ROUND_UP), 0.0);
-        assertEquals(1.2346f, MathUtils.round(x, 4, BigDecimal.ROUND_UP), 0.0);
-        assertEquals(-1.24f, MathUtils.round(-x, 2, BigDecimal.ROUND_UP), 0.0);
-        assertEquals(-1.235f, MathUtils.round(-x, 3, BigDecimal.ROUND_UP), 0.0);
-        assertEquals(-1.2346f, MathUtils.round(-x, 4, BigDecimal.ROUND_UP), 0.0);
+        Assert.assertEquals(1.24f, MathUtils.round(x, 2, BigDecimal.ROUND_UP), 0.0);
+        Assert.assertEquals(1.235f, MathUtils.round(x, 3, BigDecimal.ROUND_UP), 0.0);
+        Assert.assertEquals(1.2346f, MathUtils.round(x, 4, BigDecimal.ROUND_UP), 0.0);
+        Assert.assertEquals(-1.24f, MathUtils.round(-x, 2, BigDecimal.ROUND_UP), 0.0);
+        Assert.assertEquals(-1.235f, MathUtils.round(-x, 3, BigDecimal.ROUND_UP), 0.0);
+        Assert.assertEquals(-1.2346f, MathUtils.round(-x, 4, BigDecimal.ROUND_UP), 0.0);
 
         try {
             MathUtils.round(1.234f, 2, 1923);
-            fail();
+            Assert.fail();
         } catch (MathIllegalArgumentException ex) {
             // success
         }
 
         // special values
         TestUtils.assertEquals(Float.NaN, MathUtils.round(Float.NaN, 2), 0.0f);
-        assertEquals(0.0f, MathUtils.round(0.0f, 2), 0.0f);
-        assertEquals(Float.POSITIVE_INFINITY, MathUtils.round(Float.POSITIVE_INFINITY, 2), 0.0f);
-        assertEquals(Float.NEGATIVE_INFINITY, MathUtils.round(Float.NEGATIVE_INFINITY, 2), 0.0f);
+        Assert.assertEquals(0.0f, MathUtils.round(0.0f, 2), 0.0f);
+        Assert.assertEquals(Float.POSITIVE_INFINITY, MathUtils.round(Float.POSITIVE_INFINITY, 2), 0.0f);
+        Assert.assertEquals(Float.NEGATIVE_INFINITY, MathUtils.round(Float.NEGATIVE_INFINITY, 2), 0.0f);
     }
 
+    @Test
     public void testSignByte() {
-        assertEquals((byte) 1, MathUtils.sign((byte) 2));
-        assertEquals((byte) 0, MathUtils.sign((byte) 0));
-        assertEquals((byte) (-1), MathUtils.sign((byte) (-2)));
+        Assert.assertEquals((byte) 1, MathUtils.sign((byte) 2));
+        Assert.assertEquals((byte) 0, MathUtils.sign((byte) 0));
+        Assert.assertEquals((byte) (-1), MathUtils.sign((byte) (-2)));
     }
 
+    @Test
     public void testSignDouble() {
         double delta = 0.0;
-        assertEquals(1.0, MathUtils.sign(2.0), delta);
-        assertEquals(0.0, MathUtils.sign(0.0), delta);
-        assertEquals(-1.0, MathUtils.sign(-2.0), delta);
+        Assert.assertEquals(1.0, MathUtils.sign(2.0), delta);
+        Assert.assertEquals(0.0, MathUtils.sign(0.0), delta);
+        Assert.assertEquals(-1.0, MathUtils.sign(-2.0), delta);
         TestUtils.assertSame(-0. / 0., MathUtils.sign(Double.NaN));
     }
 
+    @Test
     public void testSignFloat() {
         float delta = 0.0F;
-        assertEquals(1.0F, MathUtils.sign(2.0F), delta);
-        assertEquals(0.0F, MathUtils.sign(0.0F), delta);
-        assertEquals(-1.0F, MathUtils.sign(-2.0F), delta);
+        Assert.assertEquals(1.0F, MathUtils.sign(2.0F), delta);
+        Assert.assertEquals(0.0F, MathUtils.sign(0.0F), delta);
+        Assert.assertEquals(-1.0F, MathUtils.sign(-2.0F), delta);
         TestUtils.assertSame(Float.NaN, MathUtils.sign(Float.NaN));
     }
 
+    @Test
     public void testSignInt() {
-        assertEquals(1, MathUtils.sign(2));
-        assertEquals(0, MathUtils.sign(0));
-        assertEquals((-1), MathUtils.sign((-2)));
+        Assert.assertEquals(1, MathUtils.sign(2));
+        Assert.assertEquals(0, MathUtils.sign(0));
+        Assert.assertEquals((-1), MathUtils.sign((-2)));
     }
 
+    @Test
     public void testSignLong() {
-        assertEquals(1L, MathUtils.sign(2L));
-        assertEquals(0L, MathUtils.sign(0L));
-        assertEquals(-1L, MathUtils.sign(-2L));
+        Assert.assertEquals(1L, MathUtils.sign(2L));
+        Assert.assertEquals(0L, MathUtils.sign(0L));
+        Assert.assertEquals(-1L, MathUtils.sign(-2L));
     }
 
+    @Test
     public void testSignShort() {
-        assertEquals((short) 1, MathUtils.sign((short) 2));
-        assertEquals((short) 0, MathUtils.sign((short) 0));
-        assertEquals((short) (-1), MathUtils.sign((short) (-2)));
+        Assert.assertEquals((short) 1, MathUtils.sign((short) 2));
+        Assert.assertEquals((short) 0, MathUtils.sign((short) 0));
+        Assert.assertEquals((short) (-1), MathUtils.sign((short) (-2)));
     }
 
+    @Test
     public void testSinh() {
         double x = 3.0;
         double expected = 10.01787;
-        assertEquals(expected, MathUtils.sinh(x), 1.0e-5);
+        Assert.assertEquals(expected, MathUtils.sinh(x), 1.0e-5);
     }
 
+    @Test
     public void testSinhNaN() {
-        assertTrue(Double.isNaN(MathUtils.sinh(Double.NaN)));
+        Assert.assertTrue(Double.isNaN(MathUtils.sinh(Double.NaN)));
     }
 
+    @Test
     public void testSubAndCheck() {
         int big = Integer.MAX_VALUE;
         int bigNeg = Integer.MIN_VALUE;
-        assertEquals(big, MathUtils.subAndCheck(big, 0));
-        assertEquals(bigNeg + 1, MathUtils.subAndCheck(bigNeg, -1));
-        assertEquals(-1, MathUtils.subAndCheck(bigNeg, -big));
+        Assert.assertEquals(big, MathUtils.subAndCheck(big, 0));
+        Assert.assertEquals(bigNeg + 1, MathUtils.subAndCheck(bigNeg, -1));
+        Assert.assertEquals(-1, MathUtils.subAndCheck(bigNeg, -big));
         try {
             MathUtils.subAndCheck(big, -1);
-            fail("Expecting MathArithmeticException");
+            Assert.fail("Expecting MathArithmeticException");
         } catch (MathArithmeticException ex) {
         }
         try {
             MathUtils.subAndCheck(bigNeg, 1);
-            fail("Expecting MathArithmeticException");
+            Assert.fail("Expecting MathArithmeticException");

[... 452 lines stripped ...]