Merge 4fd2f59 into 934be57

apache · Jun 14, 2019 · d74cd15 · d74cd15
2 parents 934be57 + 4fd2f59
commit d74cd15
Show file tree

Hide file tree

Showing 49 changed files with 1,959 additions and 1,731 deletions.
diff --git a/...s-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleRadiansTest.java b/...s-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleRadiansTest.java
@@ -13,8 +13,8 @@
  */
 package org.apache.commons.numbers.angle;
 
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 /**
  * Test cases for the {@link PlaneAngleRadians} class.
@@ -27,10 +27,10 @@ public void testNormalize() {
         for (double a = -15.0; a <= 15.0; a += 0.1) {
             for (double b = -15.0; b <= 15.0; b += 0.2) {
                 final double c = PlaneAngleRadians.normalize(a, b);
-                Assert.assertTrue((b - Math.PI) <= c);
-                Assert.assertTrue(c <= (b + Math.PI));
+                Assertions.assertTrue((b - Math.PI) <= c);
+                Assertions.assertTrue(c <= (b + Math.PI));
                 double twoK = Math.rint((a - c) / Math.PI);
-                Assert.assertEquals(c, a - twoK * Math.PI, 1e-14);
+                Assertions.assertEquals(c, a - twoK * Math.PI, 1e-14);
             }
         }
     }
@@ -41,31 +41,31 @@ public void testNormalizeBetweenMinusPiAndPi1() {
         final double expected = 0.25 * TWO_PI;
         final double actual = PlaneAngleRadians.normalizeBetweenMinusPiAndPi(value);
         final double tol = Math.ulp(expected);
-        Assert.assertEquals(expected, actual, tol);
+        Assertions.assertEquals(expected, actual, tol);
     }
     @Test
     public void testNormalizeBetweenMinusPiAndPi2() {
         final double value = 0.75 * TWO_PI;
         final double expected = -0.25 * TWO_PI;
         final double actual = PlaneAngleRadians.normalizeBetweenMinusPiAndPi(value);
         final double tol = Math.ulp(expected);
-        Assert.assertEquals(expected, actual, tol);
+        Assertions.assertEquals(expected, actual, tol);
     }
     @Test
     public void testNormalizeBetweenMinusPiAndPi3() {
         final double value = 0.5 * TWO_PI + 1e-10;
         final double expected = -0.5 * TWO_PI + 1e-10;
         final double actual = PlaneAngleRadians.normalizeBetweenMinusPiAndPi(value);
         final double tol = Math.ulp(expected);
-        Assert.assertEquals(expected, actual, tol);
+        Assertions.assertEquals(expected, actual, tol);
     }
     @Test
     public void testNormalizeBetweenMinusPiAndPi4() {
         final double value = 5 * Math.PI / 4;
         final double expected = Math.PI * (1d / 4 - 1);
         final double actual = PlaneAngleRadians.normalizeBetweenMinusPiAndPi(value);
         final double tol = Math.ulp(expected);
-        Assert.assertEquals(expected, actual, tol);
+        Assertions.assertEquals(expected, actual, tol);
     }
 
     @Test
@@ -74,15 +74,15 @@ public void testNormalizeBetweenMinusPiAndPi_lowerBound() {
         final double expected = -Math.PI;
         final double actual = PlaneAngleRadians.normalizeBetweenMinusPiAndPi(value);
         final double tol = Math.ulp(expected);
-        Assert.assertEquals(expected, actual, tol);
+        Assertions.assertEquals(expected, actual, tol);
     }
     @Test
     public void testNormalizeBetweenMinusPiAndPi_upperBound() {
         final double value = +Math.PI;
         final double expected = -Math.PI;
         final double actual = PlaneAngleRadians.normalizeBetweenMinusPiAndPi(value);
         final double tol = Math.ulp(expected);
-        Assert.assertEquals(expected, actual, tol);
+        Assertions.assertEquals(expected, actual, tol);
     }
 
     @Test
@@ -91,31 +91,31 @@ public void testNormalizeBetweenZeroAndTwoPi1() {
         final double expected = 0.25 * TWO_PI;
         final double actual = PlaneAngleRadians.normalizeBetweenZeroAndTwoPi(value);
         final double tol = Math.ulp(expected);
-        Assert.assertEquals(expected, actual, tol);
+        Assertions.assertEquals(expected, actual, tol);
     }
     @Test
     public void testNormalizeBetweenZeroAndTwoPi2() {
         final double value = 1.75 * TWO_PI;
         final double expected = 0.75 * TWO_PI;
         final double actual = PlaneAngleRadians.normalizeBetweenZeroAndTwoPi(value);
         final double tol = Math.ulp(expected);
-        Assert.assertEquals(expected, actual, tol);
+        Assertions.assertEquals(expected, actual, tol);
     }
     @Test
     public void testNormalizeBetweenZeroAndTwoPi3() {
         final double value = -0.5 * TWO_PI + 1e-10;
         final double expected = 0.5 * TWO_PI + 1e-10;
         final double actual = PlaneAngleRadians.normalizeBetweenZeroAndTwoPi(value);
         final double tol = Math.ulp(expected);
-        Assert.assertEquals(expected, actual, tol);
+        Assertions.assertEquals(expected, actual, tol);
     }
     @Test
     public void testNormalizeBetweenZeroAndTwoPi4() {
         final double value = 9 * Math.PI / 4;
         final double expected = Math.PI / 4;
         final double actual = PlaneAngleRadians.normalizeBetweenZeroAndTwoPi(value);
         final double tol = Math.ulp(expected);
-        Assert.assertEquals(expected, actual, tol);
+        Assertions.assertEquals(expected, actual, tol);
     }
 
     @Test
@@ -124,14 +124,14 @@ public void testNormalizeBetweenZeroAndTwoPi_lowerBound() {
         final double expected = 0.0;
         final double actual = PlaneAngleRadians.normalizeBetweenZeroAndTwoPi(value);
         final double tol = Math.ulp(expected);
-        Assert.assertEquals(expected, actual, tol);
+        Assertions.assertEquals(expected, actual, tol);
     }
     @Test
     public void testNormalizeBetweenZeroAndTwoPi_upperBound() {
         final double value = 2.0 * Math.PI;
         final double expected = 0.0;
         final double actual = PlaneAngleRadians.normalizeBetweenZeroAndTwoPi(value);
         final double tol = Math.ulp(expected);
-        Assert.assertEquals(expected, actual, tol);
+        Assertions.assertEquals(expected, actual, tol);
     }
 }
diff --git a/commons-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleTest.java b/commons-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleTest.java
@@ -13,8 +13,8 @@
  */
 package org.apache.commons.numbers.angle;
 
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 /**
  * Test cases for the {@link PlaneAngle} class.
@@ -24,23 +24,23 @@ public class PlaneAngleTest {
     public void testConversionTurns() {
         final double value = 12.3456;
         final PlaneAngle a = PlaneAngle.ofTurns(value);
-        Assert.assertEquals(value, a.toTurns(), 0d);
+        Assertions.assertEquals(value, a.toTurns(), 0d);
     }
 
     @Test
     public void testConversionRadians() {
         final double one = 2 * Math.PI;
         final double value = 12.3456 * one;
         final PlaneAngle a = PlaneAngle.ofRadians(value);
-        Assert.assertEquals(value, a.toRadians(), 0d);
+        Assertions.assertEquals(value, a.toRadians(), 0d);
     }
 
     @Test
     public void testConversionDegrees() {
         final double one = 360;
         final double value = 12.3456 * one;
         final PlaneAngle a = PlaneAngle.ofDegrees(value);
-        Assert.assertEquals(value, a.toDegrees(), 0d);
+        Assertions.assertEquals(value, a.toDegrees(), 0d);
     }
 
     @Test
@@ -50,10 +50,10 @@ public void testNormalizeRadians() {
                 final PlaneAngle aA = PlaneAngle.ofRadians(a);
                 final PlaneAngle aB = PlaneAngle.ofRadians(b);
                 final double c = aA.normalize(aB).toRadians();
-                Assert.assertTrue((b - Math.PI) <= c);
-                Assert.assertTrue(c <= (b + Math.PI));
+                Assertions.assertTrue((b - Math.PI) <= c);
+                Assertions.assertTrue(c <= (b + Math.PI));
                 double twoK = Math.rint((a - c) / Math.PI);
-                Assert.assertEquals(c, a - twoK * Math.PI, 1e-14);
+                Assertions.assertEquals(c, a - twoK * Math.PI, 1e-14);
             }
         }
     }
@@ -65,10 +65,10 @@ public void testNormalizeMixed() {
                 final PlaneAngle aA = PlaneAngle.ofDegrees(a);
                 final PlaneAngle aB = PlaneAngle.ofRadians(b);
                 final double c = aA.normalize(aB).toTurns();
-                Assert.assertTrue((aB.toTurns() - 0.5) <= c);
-                Assert.assertTrue(c <= (aB.toTurns() + 0.5));
+                Assertions.assertTrue((aB.toTurns() - 0.5) <= c);
+                Assertions.assertTrue(c <= (aB.toTurns() + 0.5));
                 double twoK = Math.rint((aA.toTurns() - c));
-                Assert.assertEquals(c, aA.toTurns() - twoK, 1e-14);
+                Assertions.assertEquals(c, aA.toTurns() - twoK, 1e-14);
             }
         }
     }
@@ -79,31 +79,31 @@ public void testNormalizeAroundZero1() {
         final double expected = 0.25;
         final double actual = PlaneAngle.ofTurns(value).normalize(PlaneAngle.ZERO).toTurns();
         final double tol = Math.ulp(expected);
-        Assert.assertEquals(expected, actual, tol);
+        Assertions.assertEquals(expected, actual, tol);
     }
     @Test
     public void testNormalizeAroundZero2() {
         final double value = 0.75;
         final double expected = -0.25;
         final double actual = PlaneAngle.ofTurns(value).normalize(PlaneAngle.ZERO).toTurns();
         final double tol = Math.ulp(expected);
-        Assert.assertEquals(expected, actual, tol);
+        Assertions.assertEquals(expected, actual, tol);
     }
     @Test
     public void testNormalizeAroundZero3() {
         final double value = 0.5 + 1e-10;
         final double expected = -0.5 + 1e-10;
         final double actual = PlaneAngle.ofTurns(value).normalize(PlaneAngle.ZERO).toTurns();
         final double tol = Math.ulp(expected);
-        Assert.assertEquals(expected, actual, tol);
+        Assertions.assertEquals(expected, actual, tol);
     }
     @Test
     public void testNormalizeAroundZero4() {
         final double value = 5 * Math.PI / 4;
         final double expected = Math.PI * (1d / 4 - 1);
         final double actual = PlaneAngle.ofRadians(value).normalize(PlaneAngle.ZERO).toRadians();
         final double tol = Math.ulp(expected);
-        Assert.assertEquals(expected, actual, tol);
+        Assertions.assertEquals(expected, actual, tol);
     }
 
     @Test
@@ -112,17 +112,17 @@ public void testNormalizeUpperAndLowerBounds() {
         double eps = 1e-15;
 
         // act/assert
-        Assert.assertEquals(-0.5, PlaneAngle.ofTurns(-0.5).normalize(PlaneAngle.ZERO).toTurns(), eps);
-        Assert.assertEquals(-0.5, PlaneAngle.ofTurns(0.5).normalize(PlaneAngle.ZERO).toTurns(), eps);
+        Assertions.assertEquals(-0.5, PlaneAngle.ofTurns(-0.5).normalize(PlaneAngle.ZERO).toTurns(), eps);
+        Assertions.assertEquals(-0.5, PlaneAngle.ofTurns(0.5).normalize(PlaneAngle.ZERO).toTurns(), eps);
 
-        Assert.assertEquals(-0.5, PlaneAngle.ofTurns(-1.5).normalize(PlaneAngle.ZERO).toTurns(), eps);
-        Assert.assertEquals(-0.5, PlaneAngle.ofTurns(1.5).normalize(PlaneAngle.ZERO).toTurns(), eps);
+        Assertions.assertEquals(-0.5, PlaneAngle.ofTurns(-1.5).normalize(PlaneAngle.ZERO).toTurns(), eps);
+        Assertions.assertEquals(-0.5, PlaneAngle.ofTurns(1.5).normalize(PlaneAngle.ZERO).toTurns(), eps);
 
-        Assert.assertEquals(0.0, PlaneAngle.ofTurns(0).normalize(PlaneAngle.PI).toTurns(), eps);
-        Assert.assertEquals(0.0, PlaneAngle.ofTurns(1).normalize(PlaneAngle.PI).toTurns(), eps);
+        Assertions.assertEquals(0.0, PlaneAngle.ofTurns(0).normalize(PlaneAngle.PI).toTurns(), eps);
+        Assertions.assertEquals(0.0, PlaneAngle.ofTurns(1).normalize(PlaneAngle.PI).toTurns(), eps);
 
-        Assert.assertEquals(0.0, PlaneAngle.ofTurns(-1).normalize(PlaneAngle.PI).toTurns(), eps);
-        Assert.assertEquals(0.0, PlaneAngle.ofTurns(2).normalize(PlaneAngle.PI).toTurns(), eps);
+        Assertions.assertEquals(0.0, PlaneAngle.ofTurns(-1).normalize(PlaneAngle.PI).toTurns(), eps);
+        Assertions.assertEquals(0.0, PlaneAngle.ofTurns(2).normalize(PlaneAngle.PI).toTurns(), eps);
     }
 
     @Test
@@ -134,17 +134,17 @@ public void testNormalizeVeryCloseToBounds() {
         double tiny = 1e-18; // 0.5 + tiny = 0.5 (the value is too small to add to 0.5)
 
         // act/assert
-        Assert.assertEquals(1.0 - small, PlaneAngle.ofTurns(-small).normalize(PlaneAngle.PI).toTurns(), eps);
-        Assert.assertEquals(small, PlaneAngle.ofTurns(small).normalize(PlaneAngle.PI).toTurns(), eps);
+        Assertions.assertEquals(1.0 - small, PlaneAngle.ofTurns(-small).normalize(PlaneAngle.PI).toTurns(), eps);
+        Assertions.assertEquals(small, PlaneAngle.ofTurns(small).normalize(PlaneAngle.PI).toTurns(), eps);
 
-        Assert.assertEquals(0.5 - small, PlaneAngle.ofTurns(-0.5 - small).normalize(PlaneAngle.ZERO).toTurns(), eps);
-        Assert.assertEquals(-0.5 + small, PlaneAngle.ofTurns(0.5 + small).normalize(PlaneAngle.ZERO).toTurns(), eps);
+        Assertions.assertEquals(0.5 - small, PlaneAngle.ofTurns(-0.5 - small).normalize(PlaneAngle.ZERO).toTurns(), eps);
+        Assertions.assertEquals(-0.5 + small, PlaneAngle.ofTurns(0.5 + small).normalize(PlaneAngle.ZERO).toTurns(), eps);
 
-        Assert.assertEquals(0.0, PlaneAngle.ofTurns(-tiny).normalize(PlaneAngle.PI).toTurns(), eps);
-        Assert.assertEquals(tiny, PlaneAngle.ofTurns(tiny).normalize(PlaneAngle.PI).toTurns(), eps);
+        Assertions.assertEquals(0.0, PlaneAngle.ofTurns(-tiny).normalize(PlaneAngle.PI).toTurns(), eps);
+        Assertions.assertEquals(tiny, PlaneAngle.ofTurns(tiny).normalize(PlaneAngle.PI).toTurns(), eps);
 
-        Assert.assertEquals(-0.5, PlaneAngle.ofTurns(-0.5 - tiny).normalize(PlaneAngle.ZERO).toTurns(), eps);
-        Assert.assertEquals(-0.5, PlaneAngle.ofTurns(0.5 + tiny).normalize(PlaneAngle.ZERO).toTurns(), eps);
+        Assertions.assertEquals(-0.5, PlaneAngle.ofTurns(-0.5 - tiny).normalize(PlaneAngle.ZERO).toTurns(), eps);
+        Assertions.assertEquals(-0.5, PlaneAngle.ofTurns(0.5 + tiny).normalize(PlaneAngle.ZERO).toTurns(), eps);
     }
 
     @Test
@@ -153,36 +153,36 @@ public void testHashCode() {
         final double value = -123.456789;
         final int expected = Double.valueOf(value).hashCode();
         final int actual = PlaneAngle.ofTurns(value).hashCode();
-        Assert.assertEquals(actual, expected);
+        Assertions.assertEquals(actual, expected);
     }
 
     @Test
     public void testEquals1() {
         final double value = 12345.6789;
         final PlaneAngle a = PlaneAngle.ofRadians(value);
         final PlaneAngle b = PlaneAngle.ofRadians(value);
-        Assert.assertTrue(a.equals(b));
+        Assertions.assertEquals(a, b);
     }
     @Test
     public void testEquals2() {
         final PlaneAngle a = PlaneAngle.ofRadians(153768.373486587);
         final PlaneAngle b = null;
-        Assert.assertFalse(a.equals(b));
+        Assertions.assertNotEquals(b, a);
     }
     @Test
     public void testEquals3() {
         final double value = 0.987654321;
         final PlaneAngle a = PlaneAngle.ofRadians(value);
         final PlaneAngle b = PlaneAngle.ofRadians(value + 1e-16);
-        Assert.assertFalse(a.equals(b));
+        Assertions.assertNotEquals(a, b);
     }
 
     @Test
     public void testZero() {
-        Assert.assertEquals(0, PlaneAngle.ZERO.toRadians(), 0d);
+        Assertions.assertEquals(0, PlaneAngle.ZERO.toRadians(), 0d);
     }
     @Test
     public void testPi() {
-        Assert.assertEquals(Math.PI, PlaneAngle.PI.toRadians(), 0d);
+        Assertions.assertEquals(Math.PI, PlaneAngle.PI.toRadians(), 0d);
     }
 }
diff --git a/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/CosAngleTest.java b/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/CosAngleTest.java
@@ -13,8 +13,8 @@
  */
 package org.apache.commons.numbers.arrays;
 
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 /**
  * Test cases for the {@link CosAngle} class.
@@ -26,24 +26,24 @@ public void testCosAngle2D() {
 
         final double[] v1 = { 1, 0 };
         expected = 1;
-        Assert.assertEquals(expected, CosAngle.value(v1, v1), 0d);
+        Assertions.assertEquals(expected, CosAngle.value(v1, v1), 0d);
 
         final double[] v2 = { 0, 1 };
         expected = 0;
-        Assert.assertEquals(expected, CosAngle.value(v1, v2), 0d);
+        Assertions.assertEquals(expected, CosAngle.value(v1, v2), 0d);
 
         final double[] v3 = { 7, 7 };
         expected = Math.sqrt(2) / 2;
-        Assert.assertEquals(expected, CosAngle.value(v1, v3), 1e-15);
-        Assert.assertEquals(expected, CosAngle.value(v3, v2), 1e-15);
+        Assertions.assertEquals(expected, CosAngle.value(v1, v3), 1e-15);
+        Assertions.assertEquals(expected, CosAngle.value(v3, v2), 1e-15);
 
         final double[] v4 = { -5, 0 };
         expected = -1;
-        Assert.assertEquals(expected, CosAngle.value(v1, v4), 0);
+        Assertions.assertEquals(expected, CosAngle.value(v1, v4), 0);
 
         final double[] v5 = { -100, 100 };
         expected = 0;
-        Assert.assertEquals(expected, CosAngle.value(v3, v5), 0);
+        Assertions.assertEquals(expected, CosAngle.value(v3, v5), 0);
     }
 
     @Test
@@ -52,11 +52,11 @@ public void testCosAngle3D() {
 
         final double[] v1 = { 1, 1, 0 };
         expected = 1;
-        Assert.assertEquals(expected, CosAngle.value(v1, v1), 1e-15);
+        Assertions.assertEquals(expected, CosAngle.value(v1, v1), 1e-15);
 
         final double[] v2 = { 1, 1, 1 };
         expected = Math.sqrt(2) / Math.sqrt(3);
-        Assert.assertEquals(expected, CosAngle.value(v1, v2), 1e-15);
+        Assertions.assertEquals(expected, CosAngle.value(v1, v2), 1e-15);
     }
 
     @Test
@@ -68,10 +68,10 @@ public void testCosAngleExtreme() {
         final double big = 1e200;
         final double[] v2 = { -big, -big };
         expected = -1;
-        Assert.assertEquals(expected, CosAngle.value(v1, v2), 1e-15);
+        Assertions.assertEquals(expected, CosAngle.value(v1, v2), 1e-15);
 
         final double[] v3 = { big, -big };
         expected = 0;
-        Assert.assertEquals(expected, CosAngle.value(v1, v3), 1e-15);
+        Assertions.assertEquals(expected, CosAngle.value(v1, v3), 1e-15);
     }
 }