diff --git a/commons-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleRadiansTest.java b/commons-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleRadiansTest.java
index b8fa128..7a560ed 100644
--- a/commons-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleRadiansTest.java
+++ b/commons-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleRadiansTest.java
@@ -14,7 +14,7 @@
 package org.apache.commons.numbers.angle;
 
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 /**
  * Test cases for the {@link PlaneAngleRadians} class.
diff --git a/commons-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleTest.java b/commons-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleTest.java
index d2f3ac8..a33b3a6 100644
--- a/commons-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleTest.java
+++ b/commons-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleTest.java
@@ -14,7 +14,7 @@
 package org.apache.commons.numbers.angle;
 
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 /**
  * Test cases for the {@link PlaneAngle} class.
diff --git a/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/CosAngleTest.java b/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/CosAngleTest.java
index 06b1c62..a8593b4 100644
--- a/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/CosAngleTest.java
+++ b/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/CosAngleTest.java
@@ -14,7 +14,7 @@
 package org.apache.commons.numbers.arrays;
 
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 /**
  * Test cases for the {@link CosAngle} class.
diff --git a/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/LinearCombinationTest.java b/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/LinearCombinationTest.java
index 49843ac..51d210e 100644
--- a/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/LinearCombinationTest.java
+++ b/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/LinearCombinationTest.java
@@ -14,7 +14,7 @@
 package org.apache.commons.numbers.arrays;
 
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import org.apache.commons.rng.UniformRandomProvider;
 import org.apache.commons.rng.simple.RandomSource;
diff --git a/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/SafeNormTest.java b/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/SafeNormTest.java
index dc949df..cbfbc22 100644
--- a/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/SafeNormTest.java
+++ b/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/SafeNormTest.java
@@ -14,7 +14,7 @@
 package org.apache.commons.numbers.arrays;
 
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 /**
  * Test cases for the {@link SafeNorm} class.
diff --git a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/BinomialCoefficientDoubleTest.java b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/BinomialCoefficientDoubleTest.java
index 404bfed..4f6252c 100644
--- a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/BinomialCoefficientDoubleTest.java
+++ b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/BinomialCoefficientDoubleTest.java
@@ -17,7 +17,8 @@
 package org.apache.commons.numbers.combinatorics;
 
 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 BinomialCoefficient} class.
@@ -26,7 +27,7 @@
     /** Verify that b(0,0) = 1 */
     @Test
     public void test0Choose0() {
-        Assert.assertEquals(BinomialCoefficientDouble.value(0, 0), 1d, 0);
+        Assert.assertEquals(1d, BinomialCoefficientDouble.value(0, 0), 0);
     }
 
     @Test
@@ -52,14 +53,18 @@
         }
     }
 
-    @Test(expected=CombinatoricsException.class)
+    @Test()
     public void testBinomialCoefficientFail1() {
-        BinomialCoefficientDouble.value(4, 5);
+        Assertions.assertThrows(CombinatoricsException.class,
+                () -> BinomialCoefficientDouble.value(4, 5)
+        );
     }
 
-    @Test(expected=CombinatoricsException.class)
+    @Test()
     public void testBinomialCoefficientFail2() {
-        BinomialCoefficientDouble.value(-1, -2);
+        Assertions.assertThrows(CombinatoricsException.class,
+                () -> BinomialCoefficientDouble.value(-1, -2)
+        );
     }
 
     @Test
diff --git a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/BinomialCoefficientTest.java b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/BinomialCoefficientTest.java
index d1dacc6..9abf1b6 100644
--- a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/BinomialCoefficientTest.java
+++ b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/BinomialCoefficientTest.java
@@ -22,7 +22,8 @@
 import java.util.HashMap;
 
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 import org.apache.commons.numbers.core.ArithmeticUtils;
 
@@ -70,29 +71,40 @@
         }
     }
 
-    @Test(expected=CombinatoricsException.class)
+    @Test()
     public void testBinomialCoefficientFail1() {
-        BinomialCoefficient.value(4, 5);
+        Assertions.assertThrows(CombinatoricsException.class,
+            () -> BinomialCoefficient.value(4, 5)
+        );
     }
 
-    @Test(expected=CombinatoricsException.class)
+    @Test()
     public void testBinomialCoefficientFail2() {
-        BinomialCoefficient.value(-1, -2);
+        Assertions.assertThrows(CombinatoricsException.class,
+                () -> BinomialCoefficient.value(-1, -2)
+        );
     }
 
-    @Test(expected=ArithmeticException.class)
-    public void testBinomialCoefficientFail3() {
-        BinomialCoefficient.value(67, 30);
+    @Test()
+    public void testBinomialCoefficientFail3()
+    {
+        Assertions.assertThrows(ArithmeticException.class,
+                () -> BinomialCoefficient.value(67, 30)
+        );
     }
 
-    @Test(expected=ArithmeticException.class)
+    @Test()
     public void testBinomialCoefficientFail4() {
-        BinomialCoefficient.value(67, 34);
+        Assertions.assertThrows(ArithmeticException.class,
+                () -> BinomialCoefficient.value(67, 34)
+        );
     }
 
-    @Test(expected=ArithmeticException.class)
+    @Test()
     public void testBinomialCoefficientFail5() {
-        BinomialCoefficient.value(700, 300);
+        Assertions.assertThrows(ArithmeticException.class,
+                () -> BinomialCoefficient.value(700, 300)
+        );
     }
 
     /**
@@ -139,16 +151,18 @@
 
     }
 
-    @Test(expected=CombinatoricsException.class)
-    public void testCheckBinomial1() {
-        // n < 0
-        BinomialCoefficient.checkBinomial(-1, -2);
+    @Test()
+    public void checkNLessThanOne() {
+        Assertions.assertThrows(CombinatoricsException.class,
+                () -> BinomialCoefficient.checkBinomial(-1, -2)
+        );
     }
 
-    @Test(expected=CombinatoricsException.class)
-    public void testCheckBinomial2() {
-        // k > n
-        BinomialCoefficient.checkBinomial(4, 5);
+    @Test()
+    public void checkKGreaterThanN() {
+        Assertions.assertThrows(CombinatoricsException.class,
+                () -> BinomialCoefficient.checkBinomial(4, 5)
+        );
     }
 
     @Test
diff --git a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/CombinationsTest.java b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/CombinationsTest.java
index e56bab4..227c7cb 100644
--- a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/CombinationsTest.java
+++ b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/CombinationsTest.java
@@ -20,7 +20,8 @@
 import java.util.Comparator;
 
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 /**
  * Tests for the {@link Combinations} class.
@@ -53,36 +54,44 @@
         checkLexicographicIterator(new Combinations.LexicographicComparator(123, 2));
     }
 
-    @Test(expected=IllegalArgumentException.class)
+    @Test()
     public void testLexicographicComparatorWrongIterate1() {
         final int n = 5;
         final int k = 3;
         final Comparator<int[]> comp = new Combinations.LexicographicComparator(n, k);
-        comp.compare(new int[] {1}, new int[] {0, 1, 2});
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> comp.compare(new int[] {1}, new int[] {0, 1, 2})
+        );
     }
 
-    @Test(expected=IllegalArgumentException.class)
+    @Test()
     public void testLexicographicComparatorWrongIterate2() {
         final int n = 5;
         final int k = 3;
         final Comparator<int[]> comp = new Combinations.LexicographicComparator(n, k);
-        comp.compare(new int[] {0, 1, 2}, new int[] {0, 1, 2, 3});
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> comp.compare(new int[] {0, 1, 2}, new int[] {0, 1, 2, 3})
+        );
     }
 
-    @Test(expected=IllegalArgumentException.class)
+    @Test()
     public void testLexicographicComparatorWrongIterate3() {
         final int n = 5;
         final int k = 3;
         final Comparator<int[]> comp = new Combinations.LexicographicComparator(n, k);
-        comp.compare(new int[] {1, 2, 5}, new int[] {0, 1, 2});
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> comp.compare(new int[] {1, 2, 5}, new int[] {0, 1, 2})
+        );
     }
 
-    @Test(expected=IllegalArgumentException.class)
+    @Test()
     public void testLexicographicComparatorWrongIterate4() {
         final int n = 5;
         final int k = 3;
         final Comparator<int[]> comp = new Combinations.LexicographicComparator(n, k);
-        comp.compare(new int[] {1, 2, 4}, new int[] {-1, 1, 2});
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> comp.compare(new int[] {1, 2, 4}, new int[] {-1, 1, 2})
+        );
     }
 
     @Test
@@ -155,7 +164,7 @@
      *
      * @param comp Comparator.
      */
-    private void checkLexicographicIterator(Combinations.LexicographicComparator comp) {
+    private static void checkLexicographicIterator(Combinations.LexicographicComparator comp) {
         final int n = comp.getN();
         final int k = comp.getK();
 
@@ -183,12 +192,16 @@
         Assert.assertEquals(BinomialCoefficient.value(n, k), numIterates);
     }
 
-    @Test(expected=IllegalArgumentException.class)
+    @Test()
     public void testCombinationsIteratorFail1() {
-        new Combinations(4, 5).iterator();
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> new Combinations(4, 5).iterator()
+        );
     }
-    @Test(expected=IllegalArgumentException.class)
+    @Test()
     public void testCombinationsIteratorFail2() {
-        new Combinations(-1, -2).iterator();
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> new Combinations(-1, -2).iterator()
+        );
     }
 }
diff --git a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialDoubleTest.java b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialDoubleTest.java
index 50c03ba..7491080 100644
--- a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialDoubleTest.java
+++ b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialDoubleTest.java
@@ -17,7 +17,8 @@
 package org.apache.commons.numbers.combinatorics;
 
 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 FactorialDouble} class.
@@ -50,9 +51,11 @@
                             Double.POSITIVE_INFINITY, FactorialDouble.create().value(n), 0d);
     }
 
-    @Test(expected=IllegalArgumentException.class)
+    @Test()
     public void testNonPositiveArgument() {
-        FactorialDouble.create().value(-1);
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> FactorialDouble.create().value(-1)
+        );
     }
 
     @Test
diff --git a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialTest.java b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialTest.java
index 9b5fde4..4e74dd8 100644
--- a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialTest.java
+++ b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialTest.java
@@ -17,7 +17,8 @@
 package org.apache.commons.numbers.combinatorics;
 
 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 Factorial} class.
@@ -35,14 +36,18 @@
         }
     }
 
-    @Test(expected=IllegalArgumentException.class)
+    @Test()
     public void testPrecondition1() {
-        Factorial.value(-1);
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> Factorial.value(-1)
+        );
     }
 
-    @Test(expected=IllegalArgumentException.class)
+    @Test()
     public void testPrecondition2() {
-        Factorial.value(21);
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> Factorial.value(21)
+        );
     }
 
     /**
diff --git a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogBinomialCoefficientTest.java b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogBinomialCoefficientTest.java
index 24aa734..22d3124 100644
--- a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogBinomialCoefficientTest.java
+++ b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogBinomialCoefficientTest.java
@@ -17,7 +17,8 @@
 package org.apache.commons.numbers.combinatorics;
 
 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 LogBinomialCoefficient} class.
@@ -53,14 +54,18 @@
         }
     }
 
-    @Test(expected=CombinatoricsException.class)
+    @Test()
     public void testBinomialCoefficientFail1() {
-        LogBinomialCoefficient.value(4, 5);
+        Assertions.assertThrows(CombinatoricsException.class,
+            () -> LogBinomialCoefficient.value(4, 5)
+        );
     }
 
-    @Test(expected=CombinatoricsException.class)
+    @Test()
     public void testBinomialCoefficientFail2() {
-        LogBinomialCoefficient.value(-1, -2);
+        Assertions.assertThrows(CombinatoricsException.class,
+                () -> LogBinomialCoefficient.value(-1, -2)
+        );
     }
 
     /**
diff --git a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogFactorialTest.java b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogFactorialTest.java
index bb223ba..534a2bb 100644
--- a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogFactorialTest.java
+++ b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogFactorialTest.java
@@ -19,15 +19,18 @@
 import org.apache.commons.numbers.gamma.LogGamma;
 
 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 LogFactorial} class.
  */
 public class LogFactorialTest {
-    @Test(expected=IllegalArgumentException.class)
+    @Test
     public void testNonPositiveArgument() {
-        LogFactorial.create().withCache(-1);
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> LogFactorial.create().withCache(-1)
+        );
     }
 
     @Test
diff --git a/commons-numbers-complex-streams/src/test/java/org/apache/commons/numbers/complex/streams/ComplexUtilsTest.java b/commons-numbers-complex-streams/src/test/java/org/apache/commons/numbers/complex/streams/ComplexUtilsTest.java
index 6adbf3c..dba04a5 100644
--- a/commons-numbers-complex-streams/src/test/java/org/apache/commons/numbers/complex/streams/ComplexUtilsTest.java
+++ b/commons-numbers-complex-streams/src/test/java/org/apache/commons/numbers/complex/streams/ComplexUtilsTest.java
@@ -20,7 +20,8 @@
 import org.apache.commons.numbers.complex.Complex;
 
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 /**
  * Tests for {@link ComplexUtils}.
@@ -307,24 +308,32 @@
         return Complex.I.multiply(Complex.ofCartesian(theta, 0)).exp().multiply(Complex.ofCartesian(r, 0));
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test()
     public void testPolar2ComplexIllegalModulus() {
-        ComplexUtils.polar2Complex(-1, 0);
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> ComplexUtils.polar2Complex(-1, 0)
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test()
     public void testPolar2ComplexIllegalModulus1D() {
-        ComplexUtils.polar2Complex(new double[]{0, -1, 2}, new double[]{0, 1, 2});
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> ComplexUtils.polar2Complex(new double[]{0, -1, 2}, new double[]{0, 1, 2})
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test()
     public void testPolar2ComplexIllegalModulus2D() {
-        ComplexUtils.polar2Complex(new double[][]{{0, 2, 2}, {0, -1, 2}}, new double[][]{{0, 1, 2}, {0, 1, 2}});
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> ComplexUtils.polar2Complex(new double[][]{{0, 2, 2}, {0, -1, 2}}, new double[][]{{0, 1, 2}, {0, 1, 2}})
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test()
     public void testPolar2ComplexIllegalModulus3D() {
-        ComplexUtils.polar2Complex(new double[][][]{{{0, 2, 2}}, {{0, -1, 2}}}, new double[][][]{{{0, 1, 2}}, {{0, 1, 2}}});
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> ComplexUtils.polar2Complex(new double[][][]{{{0, 2, 2}}, {{0, -1, 2}}}, new double[][][]{{{0, 1, 2}}, {{0, 1, 2}}})
+        );
     }
 
     @Test
@@ -479,104 +488,148 @@
 
     // INTERLEAVED <-> COMPLEX
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test()
     public void testComplex2InterleavedIllegalIndex2Dmin() {
-        ComplexUtils.complex2Interleaved(c2d, -1);
+        Assertions.assertThrows(IllegalArgumentException.class,
+            () -> ComplexUtils.complex2Interleaved(c2d, -1)
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test()
     public void testComplex2InterleavedIllegalIndex2Dmax() {
-        ComplexUtils.complex2Interleaved(c2d, 2);
+        Assertions.assertThrows(IllegalArgumentException.class,
+            () -> ComplexUtils.complex2Interleaved(c2d, 2)
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test()
     public void testComplex2InterleavedIllegalIndex3Dmin() {
-        ComplexUtils.complex2Interleaved(c3d, -1);
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> ComplexUtils.complex2Interleaved(c3d, -1)
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test()
     public void testComplex2InterleavedIllegalIndex3Dmax() {
-        ComplexUtils.complex2Interleaved(c3d, 3);
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> ComplexUtils.complex2Interleaved(c3d, 3)
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test()
     public void testComplex2InterleavedIllegalIndex4Dmin() {
-        ComplexUtils.complex2Interleaved(c4d, -1);
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> ComplexUtils.complex2Interleaved(c4d, -1)
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test()
     public void testComplex2InterleavedIllegalIndex4Dmax() {
-        ComplexUtils.complex2Interleaved(c4d, 4);
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> ComplexUtils.complex2Interleaved(c4d, 4)
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test()
     public void testComplex2InterleavedFloatIllegalIndex2Dmin() {
-        ComplexUtils.complex2InterleavedFloat(c2d, -1);
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> ComplexUtils.complex2InterleavedFloat(c2d, -1)
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test()
     public void testComplex2InterleavedFloatIllegalIndex2Dmax() {
-        ComplexUtils.complex2InterleavedFloat(c2d, 2);
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> ComplexUtils.complex2InterleavedFloat(c2d, 2)
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
-    public void testComplex2InterleavedFloatIllegalIndex3Dmin() {
-        ComplexUtils.complex2InterleavedFloat(c3d, -1);
+    @Test()
+    public void testComplex2InterleavedFloatIllegalIndex3Dmin()
+    {
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> ComplexUtils.complex2InterleavedFloat(c3d,-1)
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
-    public void testComplex2InterleavedFloatIllegalIndex3Dmax() {
-        ComplexUtils.complex2InterleavedFloat(c3d, 3);
+    @Test()
+    public void testComplex2InterleavedFloatIllegalIndex3Dmax()
+    {
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> ComplexUtils.complex2InterleavedFloat(c3d, 3)
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test()
     public void testInterleaved2ComplexIllegalIndex2Dmin() {
-        ComplexUtils.interleaved2Complex(di2d0, -1);
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> ComplexUtils.interleaved2Complex(di2d0, -1)
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test()
     public void testInterleaved2ComplexIllegalIndex2Dmax() {
-        ComplexUtils.interleaved2Complex(di2d0, 2);
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> ComplexUtils.interleaved2Complex(di2d0, 2)
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test()
     public void testInterleaved2ComplexIllegalIndex3Dmin() {
-        ComplexUtils.interleaved2Complex(di3d0, -1);
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> ComplexUtils.interleaved2Complex(di3d0, -1)
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
-    public void testInterleaved2ComplexIllegalIndex3Dmax() {
-        ComplexUtils.interleaved2Complex(di3d0, 3);
+    @Test()
+    public void testInterleaved2ComplexIllegalIndex3Dmax()
+    {
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> ComplexUtils.interleaved2Complex(di3d0, 3)
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test()
     public void testInterleaved2ComplexIllegalIndex4Dmin() {
-        ComplexUtils.interleaved2Complex(di4d0, -1);
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> ComplexUtils.interleaved2Complex(di4d0, -1)
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test()
     public void testInterleaved2ComplexIllegalIndex4Dmax() {
-        ComplexUtils.interleaved2Complex(di4d0, 4);
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> ComplexUtils.interleaved2Complex(di4d0, 4)
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test()
     public void testInterleaved2ComplexFloatIllegalIndex2Dmin() {
-        ComplexUtils.interleaved2Complex(fi2d0, -1);
+        Assertions.assertThrows(IllegalArgumentException.class,
+            () -> ComplexUtils.interleaved2Complex(fi2d0, -1)
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test()
     public void testInterleaved2ComplexFloatIllegalIndex2Dmax() {
-        ComplexUtils.interleaved2Complex(fi2d0, 2);
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> ComplexUtils.interleaved2Complex(fi2d0, 2)
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test()
     public void testInterleaved2ComplexFloatIllegalIndex3Dmin() {
-        ComplexUtils.interleaved2Complex(fi3d0, -1);
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> ComplexUtils.interleaved2Complex(fi3d0, -1)
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
-    public void testInterleaved2ComplexFloatIllegalIndex3Dmax() {
-        ComplexUtils.interleaved2Complex(fi3d0, 3);
+    @Test()
+    public void testInterleaved2ComplexFloatIllegalIndex3Dmax()
+    {
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> ComplexUtils.interleaved2Complex(fi3d0, 3)
+        );
     }
 
     @Test
diff --git a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CStandardTest.java b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CStandardTest.java
index c16622a..2264052 100644
--- a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CStandardTest.java
+++ b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CStandardTest.java
@@ -17,9 +17,8 @@
 
 package org.apache.commons.numbers.complex;
 
-import org.apache.commons.numbers.complex.Complex;
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 public class CStandardTest {
 
diff --git a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexTest.java b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexTest.java
index a45fff6..ed48434 100644
--- a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexTest.java
+++ b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexTest.java
@@ -17,12 +17,10 @@
 
 package org.apache.commons.numbers.complex;
 
-import java.util.List;
-
-import org.apache.commons.numbers.complex.Complex;
 import org.junit.Assert;
-import org.junit.Ignore;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 
 
 /**
@@ -390,13 +388,18 @@
         Assert.assertFalse(x.equals(null));
     }
 
-    @Test(expected=NullPointerException.class)
+    @Test()
     public void testFloatingPointEqualsPrecondition1() {
-        Complex.equals(Complex.ofCartesian(3.0, 4.0), null, 3);
+        Assertions.assertThrows(NullPointerException.class,
+                () -> Complex.equals(Complex.ofCartesian(3.0, 4.0), null, 3)
+        );
+
     }
-    @Test(expected=NullPointerException.class)
+    @Test()
     public void testFloatingPointEqualsPrecondition2() {
-        Complex.equals(null, Complex.ofCartesian(3.0, 4.0), 3);
+        Assertions.assertThrows(NullPointerException.class,
+                () -> Complex.equals(null, Complex.ofCartesian(3.0, 4.0), 3)
+        );
     }
 
     @Test
@@ -538,7 +541,7 @@
     }
 
     @Test
-    @Ignore
+    @Disabled
     public void testJava() {// TODO more debug
         System.out.println(">>testJava()");
         // MathTest#testExpSpecialCases() checks the following:
@@ -850,35 +853,47 @@
         Assert.assertTrue(Complex.ofCis(pi).equals(Complex.parse(Complex.ofCis(pi).toString())));
     }
 
-    @Test(expected=IllegalArgumentException.class)
+    @Test()
     public void testParseWrongStart() {
         final String re = "1.234";
         final String im = "5.678";
-        Complex.parse(re + "," + im + ")");
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> Complex.parse( re + "," + im + ")")
+        );
+
     }
-    @Test(expected=IllegalArgumentException.class)
+    @Test()
     public void testParseWrongEnd() {
         final String re = "1.234";
         final String im = "5.678";
-        Complex.parse("(" + re + "," + im);
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> Complex.parse("(" + re + "," + im)
+        );
+
     }
-    @Test(expected=IllegalArgumentException.class)
+    @Test()
     public void testParseMissingSeparator() {
         final String re = "1.234";
         final String im = "5.678";
-        Complex.parse("(" + re + " " + im + ")");
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> Complex.parse("(" + re + " " + im + ")")
+        );
     }
-    @Test(expected=IllegalArgumentException.class)
+    @Test()
     public void testParseInvalidRe() {
         final String re = "I.234";
         final String im = "5.678";
-        Complex.parse("(" + re + "," + im + ")");
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> Complex.parse("(" + re + "," + im + ")")
+        );
     }
-    @Test(expected=IllegalArgumentException.class)
+    @Test()
     public void testParseInvalidIm() {
         final String re = "1.234";
         final String im = "5.G78";
-        Complex.parse("(" + re + "," + im + ")");
+        Assertions.assertThrows(IllegalArgumentException.class,
+            () -> Complex.parse("(" + re + "," + im + ")")
+        );
     }
 
     @Test
diff --git a/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/ArithmeticUtilsTest.java b/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/ArithmeticUtilsTest.java
index a7185da..72ba8f3 100644
--- a/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/ArithmeticUtilsTest.java
+++ b/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/ArithmeticUtilsTest.java
@@ -21,7 +21,8 @@
 import java.util.Collections;
 
 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 ArithmeticUtils} class.
@@ -444,9 +445,11 @@
 
     }
 
-    @Test(expected=ArithmeticException.class)
+    @Test()
     public void testPowIntOverflow() {
-        ArithmeticUtils.pow(21, 8);
+        Assertions.assertThrows(ArithmeticException.class,
+                () -> ArithmeticUtils.pow(21, 8)
+        );
     }
 
     @Test
@@ -459,9 +462,11 @@
                             ArithmeticUtils.pow(base, 7));
     }
 
-    @Test(expected=ArithmeticException.class)
+    @Test()
     public void testPowNegativeIntOverflow() {
-        ArithmeticUtils.pow(-21, 8);
+        Assertions.assertThrows(ArithmeticException.class,
+                () -> ArithmeticUtils.pow(-21, 8)
+        );
     }
 
     @Test
@@ -492,9 +497,12 @@
         }
     }
 
-    @Test(expected=ArithmeticException.class)
-    public void testPowLongOverflow() {
-        ArithmeticUtils.pow(21, 15);
+    @Test()
+    public void testPowLongOverflow()
+    {
+        Assertions.assertThrows(ArithmeticException.class,
+                () -> ArithmeticUtils.pow(21, 15)
+        );
     }
 
     @Test
@@ -507,9 +515,11 @@
                             ArithmeticUtils.pow(base, 14));
     }
 
-    @Test(expected=ArithmeticException.class)
+    @Test()
     public void testPowNegativeLongOverflow() {
-        ArithmeticUtils.pow(-21L, 15);
+        Assertions.assertThrows(ArithmeticException.class,
+                () -> ArithmeticUtils.pow(-21L, 15)
+        );
     }
 
     @Test
@@ -674,24 +684,21 @@
         return toUnsignedBigInteger(dividend).divide(toUnsignedBigInteger(divisor)).longValue();
     }
 
-    @Test(timeout=5000L)
+    @Test()
     public void testRemainderUnsignedInt() {
         Assert.assertEquals(36, ArithmeticUtils.remainderUnsigned(-2147479015, 63));
         Assert.assertEquals(6, ArithmeticUtils.remainderUnsigned(-2147479015, 25));
     }
 
-    @Test(timeout=5000L)
+    @Test()
     public void testRemainderUnsignedIntSpecialCases() {
         int ints[] = getIntSpecialCases();
         for (int dividend : ints) {
             for (int divisor : ints) {
                 if (divisor == 0) {
-                    try {
-                        ArithmeticUtils.remainderUnsigned(dividend, divisor);
-                        Assert.fail("Should have failed with ArithmeticException: division by zero");
-                    } catch (ArithmeticException e) {
-                        // Success.
-                    }
+                    Assertions.assertThrows(ArithmeticException.class,
+                            () -> ArithmeticUtils.remainderUnsigned(dividend, divisor)
+                    );
                 } else {
                     Assert.assertEquals(remainderUnsignedExpected(dividend, divisor), ArithmeticUtils.remainderUnsigned(dividend, divisor));
                 }
@@ -699,12 +706,12 @@
         }
     }
 
-    @Test(timeout=5000L)
+    @Test()
     public void testRemainderUnsignedLong() {
         Assert.assertEquals(48L, ArithmeticUtils.remainderUnsigned(-2147479015L, 63L));
     }
 
-    @Test//(timeout=5000L)
+    @Test
     public void testRemainderUnsignedLongSpecialCases() {
         long longs[] = getLongSpecialCases();
         for (long dividend : longs) {
@@ -723,7 +730,7 @@
         }
     }
 
-    @Test(timeout=5000L)
+    @Test()
     public void testDivideUnsignedInt() {
         Assert.assertEquals(34087115, ArithmeticUtils.divideUnsigned(-2147479015, 63));
         Assert.assertEquals(85899531, ArithmeticUtils.divideUnsigned(-2147479015, 25));
@@ -737,18 +744,15 @@
         Assert.assertEquals(1, ArithmeticUtils.divideUnsigned(-16, 2147483646));
     }
 
-    @Test(timeout=5000L)
+    @Test()
     public void testDivideUnsignedIntSpecialCases() {
         int ints[] = getIntSpecialCases();
         for (int dividend : ints) {
             for (int divisor : ints) {
                 if (divisor == 0) {
-                    try {
-                        ArithmeticUtils.divideUnsigned(dividend, divisor);
-                        Assert.fail("Should have failed with ArithmeticException: division by zero");
-                    } catch (ArithmeticException e) {
-                        // Success.
-                    }
+                    Assertions.assertThrows(ArithmeticException.class,
+                            () -> ArithmeticUtils.divideUnsigned(dividend, divisor)
+                    );
                 } else {
                     Assert.assertEquals(divideUnsignedExpected(dividend, divisor), ArithmeticUtils.divideUnsigned(dividend, divisor));
                 }
@@ -756,23 +760,20 @@
         }
     }
 
-    @Test(timeout=5000L)
+    @Test()
     public void testDivideUnsignedLong() {
         Assert.assertEquals(292805461453366231L, ArithmeticUtils.divideUnsigned(-2147479015L, 63L));
     }
 
-    @Test(timeout=5000L)
+    @Test()
     public void testDivideUnsignedLongSpecialCases() {
         long longs[] = getLongSpecialCases();
         for (long dividend : longs) {
             for (long divisor : longs) {
                 if (divisor == 0L) {
-                    try {
-                        ArithmeticUtils.divideUnsigned(dividend, divisor);
-                        Assert.fail("Should have failed with ArithmeticException: division by zero");
-                    } catch (ArithmeticException e) {
-                        // Success.
-                    }
+                    Assertions.assertThrows(ArithmeticException.class,
+                            () -> ArithmeticUtils.divideUnsigned(dividend, divisor)
+                    );
                 } else {
                     Assert.assertEquals(divideUnsignedExpected(dividend, divisor), ArithmeticUtils.divideUnsigned(dividend, divisor));
                 }
diff --git a/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/PrecisionTest.java b/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/PrecisionTest.java
index e29af7e..759ce50 100644
--- a/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/PrecisionTest.java
+++ b/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/PrecisionTest.java
@@ -13,11 +13,10 @@
  */
 package org.apache.commons.numbers.core;
 
-import java.math.BigDecimal;
 import java.math.RoundingMode;
 
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 /**
  * Test cases for the {@link Precision} class.
diff --git a/commons-numbers-field/src/test/java/org/apache/commons/numbers/field/FieldParametricTest.java b/commons-numbers-field/src/test/java/org/apache/commons/numbers/field/FieldParametricTest.java
index faea48c..36d6ba2 100644
--- a/commons-numbers-field/src/test/java/org/apache/commons/numbers/field/FieldParametricTest.java
+++ b/commons-numbers-field/src/test/java/org/apache/commons/numbers/field/FieldParametricTest.java
@@ -16,12 +16,9 @@
  */
 package org.apache.commons.numbers.field;
 
-import java.util.Arrays;
-import java.util.List;
-import java.util.ArrayList;
-
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;
@@ -54,7 +51,7 @@
         return FieldsList.list();
     }
 
-    @Test
+    @ParameterizedTest
     public void testAdditionAssociativity() {
         final Object r1 = field.add(field.add(a, b), c);
         final Object r2 = field.add(a, field.add(b, c));
@@ -115,8 +112,8 @@
      * @param a Instance.
      * @param b Instance.
      */
-    private void assertEquals(Object a,
-                              Object b) {
+    private static void assertEquals(Object a,
+                                     Object b) {
         Assert.assertTrue(a + " != " + b,
                           a.equals(b));
     }
diff --git a/commons-numbers-fraction/src/main/java/org/apache/commons/numbers/fraction/BigFraction.java b/commons-numbers-fraction/src/main/java/org/apache/commons/numbers/fraction/BigFraction.java
index eedb910..476972b 100644
--- a/commons-numbers-fraction/src/main/java/org/apache/commons/numbers/fraction/BigFraction.java
+++ b/commons-numbers-fraction/src/main/java/org/apache/commons/numbers/fraction/BigFraction.java
@@ -26,7 +26,7 @@
  * Representation of a rational number without any overflow. This class is
  * immutable.
  */
-public class BigFraction extends Number implements Comparable<BigFraction>, Serializable {    
+public class BigFraction extends Number implements Comparable<BigFraction>, Serializable {
     /** A fraction representing "0". */
     public static final BigFraction ZERO = new BigFraction(0);
 
@@ -189,7 +189,7 @@
             denominator = BigInteger.valueOf(q1);
         }
     }
-    
+
     /**
      * Create a fraction given the double value.
      * <p>
@@ -270,7 +270,7 @@
      * @return {@link BigFraction instance
      */
     public static BigFraction of(BigInteger num, BigInteger den) {
-    	return new BigFraction(num, den);
+        return new BigFraction(num, den);
     }
 
     /**
@@ -296,7 +296,7 @@
      * @return {@link BigFraction instance
      */
     public static BigFraction from(final double value) throws IllegalArgumentException {
-    	return new BigFraction(value);
+        return new BigFraction(value);
     }
 
     /**
@@ -1172,7 +1172,7 @@
         }
         return str;
     }
-    
+
     /**
      * Parses a string that would be produced by {@link #toString()}
      * and instantiates the corresponding object.
diff --git a/commons-numbers-fraction/src/main/java/org/apache/commons/numbers/fraction/Fraction.java b/commons-numbers-fraction/src/main/java/org/apache/commons/numbers/fraction/Fraction.java
index c6ed60e..8bef75b 100644
--- a/commons-numbers-fraction/src/main/java/org/apache/commons/numbers/fraction/Fraction.java
+++ b/commons-numbers-fraction/src/main/java/org/apache/commons/numbers/fraction/Fraction.java
@@ -42,7 +42,7 @@
 
     /** The default epsilon used for convergence. */
     private static final double DEFAULT_EPSILON = 1e-5;
-    
+
     /** The denominator. */
     private final int denominator;
 
@@ -147,7 +147,7 @@
             this.denominator = (int) q1;
         }
     }
-    
+
     /**
      * Private constructor for integer fractions.
      * @param num the numerator.
@@ -256,7 +256,7 @@
      * @return {@link Fraction} instance
      */
     public static Fraction of(int num, int den) {
-    	return new Fraction(num, den);
+        return new Fraction(num, den);
     }
 
     /**
@@ -442,10 +442,10 @@
 
     /**
      * Implement add and subtract. This algorithm is similar to that
-     * described in Knuth 4.5.1. while making some concessions to 
+     * described in Knuth 4.5.1. while making some concessions to
      * performance. Note Knuth 4.5.1 Exercise 7, which observes that
      * adding two fractions with 32-bit numerators and denominators
-     * requires 65 bits in extreme cases. Here calculations are performed 
+     * requires 65 bits in extreme cases. Here calculations are performed
      * with 64-bit longs and the BigFraction class is recommended for numbers
      * that may grow large enough to be in danger of overflow.
      *
@@ -621,7 +621,7 @@
         }
         return str;
     }
-    
+
     /**
      * Parses a string that would be produced by {@link #toString()}
      * and instantiates the corresponding object.
diff --git a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/BigFractionTest.java b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/BigFractionTest.java
index 7b69a61..2234b1b 100644
--- a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/BigFractionTest.java
+++ b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/BigFractionTest.java
@@ -22,7 +22,8 @@
 import org.apache.commons.numbers.core.TestUtils;
 
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 
 public class BigFractionTest {
@@ -87,10 +88,12 @@
         }
     }
 
-    @Test(expected=FractionException.class)
+    @Test()
     public void testGoldenRatio() {
         // the golden ratio is notoriously a difficult number for continuous fraction
-        BigFraction.from((1 + Math.sqrt(5)) / 2, 1.0e-12, 25);
+        Assertions.assertThrows(FractionException.class,
+                () -> new BigFraction((1 + Math.sqrt(5)) / 2, 1.0e-12, 25)
+        );
     }
 
     // MATH-179
@@ -156,15 +159,19 @@
     }
 
     // MATH-1029
-    @Test(expected=ArithmeticException.class)
+    @Test()
     public void testPositiveValueOverflow() {
-        assertFraction((long) 1e10, 1, BigFraction.from(1e10, 1000));
+        Assertions.assertThrows(ArithmeticException.class,
+                () -> assertFraction((long) 1e10, 1, new BigFraction(1e10, 1000))
+        );
     }
 
     // MATH-1029
-    @Test(expected=ArithmeticException.class)
+    @Test()
     public void testNegativeValueOverflow() {
-        assertFraction((long) -1e10, 1, BigFraction.from(-1e10, 1000));
+        Assertions.assertThrows(ArithmeticException.class,
+                () -> assertFraction((long) -1e10, 1, new BigFraction(-1e10, 1000))
+        );
     }
 
     @Test
@@ -649,13 +656,13 @@
             Assert.assertEquals(fraction, TestUtils.serializeAndRecover(fraction));
         }
     }
-    
-    
+
+
     @Test
-    public void testParse() { 
+    public void testParse() {
         String[] validExpressions = new String[] {
-                "3", 
-                "1 / 2", 
+                "3",
+                "1 / 2",
                 "2147,483,647 / 2,147,483,648", //over largest int value
                 "9,223,372,036,854,775,807 / 9,223,372,036,854,775,808" //over largest long value
         };
@@ -668,7 +675,7 @@
         };
         int inc = 0;
         for (BigFraction fraction: fractions) {
-            Assert.assertEquals(fraction, 
+            Assert.assertEquals(fraction,
                     BigFraction.parse(validExpressions[inc]));
             inc++;
         }
diff --git a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/ContinuedFractionTest.java b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/ContinuedFractionTest.java
index 8543f0a..2943340 100644
--- a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/ContinuedFractionTest.java
+++ b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/ContinuedFractionTest.java
@@ -17,7 +17,7 @@
 package org.apache.commons.numbers.fraction;
 
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 
 /**
diff --git a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionTest.java b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionTest.java
index 10c3a20..444f2ef 100644
--- a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionTest.java
+++ b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionTest.java
@@ -18,7 +18,8 @@
 
 import org.apache.commons.numbers.core.TestUtils;
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 
 /**
@@ -61,10 +62,12 @@
         assertFraction(15, 1, Fraction.from(15.0000000000001));
     }
 
-    @Test(expected=ArithmeticException.class)
+    @Test()
     public void testGoldenRatio() {
         // the golden ratio is notoriously a difficult number for continuous fraction
-        Fraction.from((1 + Math.sqrt(5)) / 2, 1.0e-12, 25);
+        Assertions.assertThrows(ArithmeticException.class,
+                () -> new Fraction((1 + Math.sqrt(5)) / 2, 1.0e-12, 25)
+        );
     }
 
     // MATH-179
@@ -627,7 +630,7 @@
             Assert.assertEquals(fraction, TestUtils.serializeAndRecover(fraction));
         }
     }
-    
+
     @Test
     public void testParse() {
         String[] validExpressions = new String[] {
@@ -641,8 +644,7 @@
         };
         int inc = 0;
         for (Fraction fraction: fractions) {
-            Assert.assertEquals(fraction, 
-                    Fraction.parse(validExpressions[inc]));
+            Assert.assertEquals(fraction,Fraction.parse(validExpressions[inc]));
             inc++;
         }
     }
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/DigammaTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/DigammaTest.java
index 17b459a..6985104 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/DigammaTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/DigammaTest.java
@@ -16,8 +16,8 @@
  */
 package org.apache.commons.numbers.gamma;
 
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 /**
  * Tests for {@link Digamma}.
@@ -26,18 +26,18 @@
     @Test
     public void testDigammaLargeArgs() {
         double eps = 1e-8;
-        Assert.assertEquals(4.6001618527380874002, Digamma.value(100), eps);
-        Assert.assertEquals(3.9019896734278921970, Digamma.value(50), eps);
-        Assert.assertEquals(2.9705239922421490509, Digamma.value(20), eps);
-        Assert.assertEquals(2.9958363947076465821, Digamma.value(20.5), eps);
-        Assert.assertEquals(2.2622143570941481605, Digamma.value(10.1), eps);
-        Assert.assertEquals(2.1168588189004379233, Digamma.value(8.8), eps);
-        Assert.assertEquals(1.8727843350984671394, Digamma.value(7), eps);
-        Assert.assertEquals(0.42278433509846713939, Digamma.value(2), eps);
-        Assert.assertEquals(-100.56088545786867450, Digamma.value(0.01), eps);
-        Assert.assertEquals(-4.0390398965921882955, Digamma.value(-0.8), eps);
-        Assert.assertEquals(4.2003210041401844726, Digamma.value(-6.3), eps);
-        Assert.assertEquals(-3.110625123035E-5, Digamma.value(1.4616), eps);
+        Assertions.assertEquals(4.6001618527380874002, Digamma.value(100), eps);
+        Assertions.assertEquals(3.9019896734278921970, Digamma.value(50), eps);
+        Assertions.assertEquals(2.9705239922421490509, Digamma.value(20), eps);
+        Assertions.assertEquals(2.9958363947076465821, Digamma.value(20.5), eps);
+        Assertions.assertEquals(2.2622143570941481605, Digamma.value(10.1), eps);
+        Assertions.assertEquals(2.1168588189004379233, Digamma.value(8.8), eps);
+        Assertions.assertEquals(1.8727843350984671394, Digamma.value(7), eps);
+        Assertions.assertEquals(0.42278433509846713939, Digamma.value(2), eps);
+        Assertions.assertEquals(-100.56088545786867450, Digamma.value(0.01), eps);
+        Assertions.assertEquals(-4.0390398965921882955, Digamma.value(-0.8), eps);
+        Assertions.assertEquals(4.2003210041401844726, Digamma.value(-6.3), eps);
+        Assertions.assertEquals(-3.110625123035E-5, Digamma.value(1.4616), eps);
     }
 
     @Test
@@ -57,16 +57,16 @@
 
     @Test
     public void testDigammaNonRealArgs() {
-        Assert.assertTrue(Double.isNaN(Digamma.value(Double.NaN)));
-        Assert.assertTrue(Double.isInfinite(Digamma.value(Double.POSITIVE_INFINITY)));
-        Assert.assertTrue(Double.isInfinite(Digamma.value(Double.NEGATIVE_INFINITY)));
+        Assertions.assertTrue(Double.isNaN(Digamma.value(Double.NaN)));
+        Assertions.assertTrue(Double.isInfinite(Digamma.value(Double.POSITIVE_INFINITY)));
+        Assertions.assertTrue(Double.isInfinite(Digamma.value(Double.NEGATIVE_INFINITY)));
     }
 
     private void checkRelativeError(String msg,
                                     double expected,
                                     double actual,
                                     double tolerance) {
-        Assert.assertEquals(msg, expected, actual, Math.abs(tolerance * actual));
+        Assertions.assertEquals(expected, actual, Math.abs(tolerance * actual), msg);
     }
 }
 
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfDifferenceTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfDifferenceTest.java
index 8e9afad..ee49a8f 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfDifferenceTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfDifferenceTest.java
@@ -16,8 +16,8 @@
  */
 package org.apache.commons.numbers.gamma;
 
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 /**
  * Tests for {@link ErfDifference}.
@@ -35,8 +35,8 @@
                 double a = ErfDifference.value(x1, x2);
                 double b = Erf.value(x2) - Erf.value(x1);
                 double c = Erfc.value(x1) - Erfc.value(x2);
-                Assert.assertEquals(a, b, 1e-15);
-                Assert.assertEquals(a, c, 1e-15);
+                Assertions.assertEquals(a, b, 1e-15);
+                Assertions.assertEquals(a, c, 1e-15);
             }
         }
     }
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfTest.java
index 11fff47..ddddbf0 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfTest.java
@@ -17,7 +17,7 @@
 package org.apache.commons.numbers.gamma;
 
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 /**
  * Tests for {@link Erf}.
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfcTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfcTest.java
index e68ee18..1257152 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfcTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfcTest.java
@@ -16,8 +16,8 @@
  */
 package org.apache.commons.numbers.gamma;
 
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 /**
  * Tests for {@link Erfc}.
@@ -45,7 +45,7 @@
 
         double x = -10;
         for (int i = 0; i < 41; i++) {
-            Assert.assertEquals(gnuValues[i], Erfc.value(x), tol);
+            Assertions.assertEquals(gnuValues[i], Erfc.value(x), tol);
             x += 0.5d;
         }
     }
@@ -78,8 +78,8 @@
 
         for (int i = 0; i < 15; i++) {
             final double result = 0.5 * Erfc.value(ref[i][0] / Math.sqrt(2));
-            Assert.assertEquals(ref[i][1], result, 1e-15);
-            Assert.assertEquals(1, ref[i][1] / result, 1e-13);
+            Assertions.assertEquals(ref[i][1], result, 1e-15);
+            Assertions.assertEquals(1, ref[i][1] / result, 1e-13);
         }
     }
 }
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/GammaTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/GammaTest.java
index 87bdbac..4fe03fd 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/GammaTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/GammaTest.java
@@ -17,7 +17,7 @@
 package org.apache.commons.numbers.gamma;
 
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 /**
  * Tests for {@link Gamma}.
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InvGamma1pm1Test.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InvGamma1pm1Test.java
index 008dec4..99e955c 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InvGamma1pm1Test.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InvGamma1pm1Test.java
@@ -17,7 +17,8 @@
 package org.apache.commons.numbers.gamma;
 
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 /**
  * Tests for {@link InvGamma1pm1}.
@@ -77,13 +78,19 @@
         }
     }
 
-    @Test(expected=GammaException.class)
-    public void testInvGamma1pm1Precondition1() {
-        InvGamma1pm1.value(-0.51);
+    @Test()
+    public void testInvGamma1pm1Precondition1()
+    {
+        Assertions.assertThrows(GammaException.class,
+                () -> InvGamma1pm1.value(-0.51)
+        );
     }
 
-    @Test(expected=GammaException.class)
-    public void testInvGamma1pm1Precondition2() {
-        InvGamma1pm1.value(1.51);
+    @Test()
+    public void testInvGamma1pm1Precondition2()
+    {
+        Assertions.assertThrows(GammaException.class,
+                () -> InvGamma1pm1.value(1.51)
+        );
     }
 }
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InverseErfTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InverseErfTest.java
index e22ee5e..8b313ef 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InverseErfTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InverseErfTest.java
@@ -17,7 +17,7 @@
 package org.apache.commons.numbers.gamma;
 
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 /**
  * Tests for {@link InverseErf}.
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InverseErfcTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InverseErfcTest.java
index 79c5c11..6fa87b1 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InverseErfcTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InverseErfcTest.java
@@ -17,7 +17,7 @@
 package org.apache.commons.numbers.gamma;
 
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 /**
  * Tests for {@link InverseErfc}.
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LanczosApproximationTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LanczosApproximationTest.java
index a236662..ba5b22a 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LanczosApproximationTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LanczosApproximationTest.java
@@ -17,7 +17,7 @@
 package org.apache.commons.numbers.gamma;
 
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 /**
  * Tests for {@link LanczosApproximation}.
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogBetaTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogBetaTest.java
index f9c1c0e..1633529 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogBetaTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogBetaTest.java
@@ -19,7 +19,8 @@
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 /**
  * Tests for {@link LogBeta}.
@@ -506,14 +507,19 @@
         }
     }
 
-    @Test(expected=IllegalArgumentException.class)
-    public void testLogGammaMinusLogGammaSumPrecondition1() {
-        logGammaMinusLogGammaSum(-1, 8);
+    @Test()
+    public void testLogGammaMinusLogGammaSumPrecondition1()
+    {
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> logGammaMinusLogGammaSum(-1, 8)
+        );
     }
 
-    @Test(expected=IllegalArgumentException.class)
+    @Test()
     public void testLogGammaMinusLogGammaSumPrecondition2() {
-        logGammaMinusLogGammaSum(1, 7);
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> logGammaMinusLogGammaSum(1, 7)
+        );
     }
 
     private static final double[][] SUM_DELTA_MINUS_DELTA_SUM_REF = {
@@ -682,13 +688,18 @@
         }
     }
 
-    @Test(expected=IllegalArgumentException.class)
+    @Test()
     public void testSumDeltaMinusDeltaSumPrecondition1() {
-        sumDeltaMinusDeltaSum(9, 10);
+        Assertions.assertThrows(IllegalArgumentException.class,
+            () -> sumDeltaMinusDeltaSum(9, 10)
+        );
     }
 
-    @Test(expected=IllegalArgumentException.class)
-    public void testSumDeltaMinusDeltaSumPrecondition2() {
-        sumDeltaMinusDeltaSum(10, 9);
+    @Test()
+    public void testSumDeltaMinusDeltaSumPrecondition2()
+    {
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> sumDeltaMinusDeltaSum(10, 9)
+        );
     }
 }
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGamma1pTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGamma1pTest.java
index 647ccee..3b9f56b 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGamma1pTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGamma1pTest.java
@@ -17,7 +17,8 @@
 package org.apache.commons.numbers.gamma;
 
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 /**
  * Tests for {@link LogGamma1p}.
@@ -56,13 +57,17 @@
         }
     }
 
-    @Test(expected=GammaException.class)
+    @Test()
     public void testLogGamma1pPrecondition1() {
-        LogGamma1p.value(-0.51);
+        Assertions.assertThrows(GammaException.class,
+                () -> LogGamma1p.value(-0.51)
+        );
     }
 
-    @Test(expected=GammaException.class)
+    @Test()
     public void testLogGamma1pPrecondition2() {
-        LogGamma1p.value(1.51);
+        Assertions.assertThrows(GammaException.class,
+                () -> LogGamma1p.value(1.51)
+        );
     }
 }
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGammaSumTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGammaSumTest.java
index 7c567a4..9eed629 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGammaSumTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGammaSumTest.java
@@ -17,7 +17,8 @@
 package org.apache.commons.numbers.gamma;
 
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 /**
  * Tests for {@link LogGammaSum}.
@@ -144,23 +145,31 @@
         }
     }
 
-    @Test(expected=IllegalArgumentException.class)
+    @Test()
     public void testLogGammaSumPrecondition1() {
-        LogGammaSum.value(0, 1);
+        Assertions.assertThrows(IllegalArgumentException.class,
+            () -> LogGammaSum.value(0, 1)
+        );
     }
 
-    @Test(expected=IllegalArgumentException.class)
+    @Test()
     public void testLogGammaSumPrecondition2() {
-        LogGammaSum.value(3, 1);
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> LogGammaSum.value(3, 1)
+        );
     }
 
-    @Test(expected=IllegalArgumentException.class)
+    @Test()
     public void testLogGammaSumPrecondition3() {
-        LogGammaSum.value(1, 0);
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> LogGammaSum.value(1, 0)
+        );
     }
 
-    @Test(expected=IllegalArgumentException.class)
+    @Test()
     public void testLogGammaSumPrecondition4() {
-        LogGammaSum.value(1, 3);
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> LogGammaSum.value(1, 3)
+        );
     }
 }
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGammaTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGammaTest.java
index 0a01ddb..e36741d 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGammaTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGammaTest.java
@@ -17,7 +17,7 @@
 package org.apache.commons.numbers.gamma;
 
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 /**
  * Tests for {@link LogGamma}.
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/RegularizedBetaTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/RegularizedBetaTest.java
index 9f1c351..7b49d97 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/RegularizedBetaTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/RegularizedBetaTest.java
@@ -17,7 +17,7 @@
 package org.apache.commons.numbers.gamma;
 
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 /**
  * Tests for {@link RegularizedBeta}.
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/RegularizedGammaTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/RegularizedGammaTest.java
index 0b0eed4..a6bf915 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/RegularizedGammaTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/RegularizedGammaTest.java
@@ -17,7 +17,7 @@
 package org.apache.commons.numbers.gamma;
 
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 /**
  * Tests for {@link RegularizedGamma}.
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/TrigammaTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/TrigammaTest.java
index 50caf0b..6bb6b4f 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/TrigammaTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/TrigammaTest.java
@@ -17,7 +17,7 @@
 package org.apache.commons.numbers.gamma;
 
 import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 /**
  * Tests for {@link Trigamma}.
diff --git a/commons-numbers-primes/src/test/java/org/apache/commons/numbers/primes/PrimesTest.java b/commons-numbers-primes/src/test/java/org/apache/commons/numbers/primes/PrimesTest.java
index 983dd11..0ca314a 100644
--- a/commons-numbers-primes/src/test/java/org/apache/commons/numbers/primes/PrimesTest.java
+++ b/commons-numbers-primes/src/test/java/org/apache/commons/numbers/primes/PrimesTest.java
@@ -21,8 +21,8 @@
 import java.util.HashSet;
 import java.util.List;
 
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 public class PrimesTest {
 
@@ -60,44 +60,44 @@
     void assertPrimeFactorsException(int n, String expected) {
         try {
             Primes.primeFactors(n);
-            Assert.fail("Exception not thrown");
+            Assertions.fail("Exception not thrown");
         } catch (IllegalArgumentException e) {
-            Assert.assertEquals(expected, e.getMessage());
+            Assertions.assertEquals(expected, e.getMessage());
         }
     }
     void assertNextPrimeException(int n, String expected){
         try {
             Primes.nextPrime(n);
-            Assert.fail("Exception not thrown");
+            Assertions.fail("Exception not thrown");
         } catch(IllegalArgumentException e) {
-            Assert.assertEquals(expected, e.getMessage());
+            Assertions.assertEquals(expected, e.getMessage());
         }
     }
 
     @Test
     public void testNextPrime() {
 
-        Assert.assertEquals(2, Primes.nextPrime(0));
-        Assert.assertEquals(2, Primes.nextPrime(1));
-        Assert.assertEquals(2, Primes.nextPrime(2));
-        Assert.assertEquals(3, Primes.nextPrime(3));
-        Assert.assertEquals(5, Primes.nextPrime(4));
-        Assert.assertEquals(5, Primes.nextPrime(5));
+        Assertions.assertEquals(2, Primes.nextPrime(0));
+        Assertions.assertEquals(2, Primes.nextPrime(1));
+        Assertions.assertEquals(2, Primes.nextPrime(2));
+        Assertions.assertEquals(3, Primes.nextPrime(3));
+        Assertions.assertEquals(5, Primes.nextPrime(4));
+        Assertions.assertEquals(5, Primes.nextPrime(5));
 
         for (int i = 0; i < SmallPrimes.PRIMES.length - 1; i++) {
             for (int j = SmallPrimes.PRIMES[i] + 1; j <= SmallPrimes.PRIMES[i + 1]; j++) {
-                Assert.assertEquals(SmallPrimes.PRIMES[i+1], Primes.nextPrime(j));
+                Assertions.assertEquals(SmallPrimes.PRIMES[i+1], Primes.nextPrime(j));
             }
         }
 
-        Assert.assertEquals(25325981, Primes.nextPrime(25325981));
+        Assertions.assertEquals(25325981, Primes.nextPrime(25325981));
         for (int i = 25325981 + 1; i <= 25326023; i++) {
-            Assert.assertEquals(25326023, Primes.nextPrime(i));
+            Assertions.assertEquals(25326023, Primes.nextPrime(i));
         }
 
-        Assert.assertEquals(Integer.MAX_VALUE, Primes.nextPrime(Integer.MAX_VALUE - 10));
-        Assert.assertEquals(Integer.MAX_VALUE, Primes.nextPrime(Integer.MAX_VALUE - 1));
-        Assert.assertEquals(Integer.MAX_VALUE, Primes.nextPrime(Integer.MAX_VALUE));
+        Assertions.assertEquals(Integer.MAX_VALUE, Primes.nextPrime(Integer.MAX_VALUE - 10));
+        Assertions.assertEquals(Integer.MAX_VALUE, Primes.nextPrime(Integer.MAX_VALUE - 1));
+        Assertions.assertEquals(Integer.MAX_VALUE, Primes.nextPrime(Integer.MAX_VALUE));
 
         assertNextPrimeException(Integer.MIN_VALUE, MessageFormat.format(Primes.NUMBER_TOO_SMALL,Integer.MIN_VALUE,0));
         assertNextPrimeException(-1, MessageFormat.format(Primes.NUMBER_TOO_SMALL,-1,0));
@@ -107,13 +107,13 @@
     @Test
     public void testIsPrime() throws Exception {
         for (int i : BELOW_2) {
-            Assert.assertFalse(Primes.isPrime(i));
+            Assertions.assertFalse(Primes.isPrime(i));
         }
         for (int i:NOT_PRIMES) {
-            Assert.assertFalse(Primes.isPrime(i));
+            Assertions.assertFalse(Primes.isPrime(i));
         }
         for (int i:PRIMES) {
-            Assert.assertTrue(Primes.isPrime(i));
+            Assertions.assertTrue(Primes.isPrime(i));
         }
     }
 
@@ -140,7 +140,7 @@
     static void checkPrimeFactors(List<Integer> factors){
         for (int p : factors) {
             if (!PRIMES_SET.contains(p)) {
-                Assert.fail("Not found in primes list: " + p);
+                Assertions.fail("Not found in primes list: " + p);
             }
         }
     }
@@ -154,12 +154,12 @@
             List<Integer> factors = Primes.primeFactors(i);
             checkPrimeFactors(factors);
             int prod = product(factors);
-            Assert.assertEquals(i, prod);
+            Assertions.assertEquals(i, prod);
         }
         for (int i : PRIMES) {
             List<Integer> factors = Primes.primeFactors(i);
-            Assert.assertEquals(i, (int)factors.get(0));
-            Assert.assertEquals(1, factors.size());
+            Assertions.assertEquals(i, (int)factors.get(0));
+            Assertions.assertEquals(1, factors.size());
         }
     }
 }
diff --git a/commons-numbers-primes/src/test/java/org/apache/commons/numbers/primes/SmallPrimesTest.java b/commons-numbers-primes/src/test/java/org/apache/commons/numbers/primes/SmallPrimesTest.java
index 4aa784b..06023c5 100644
--- a/commons-numbers-primes/src/test/java/org/apache/commons/numbers/primes/SmallPrimesTest.java
+++ b/commons-numbers-primes/src/test/java/org/apache/commons/numbers/primes/SmallPrimesTest.java
@@ -20,8 +20,9 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
-import org.junit.Assert;
-import org.junit.Test;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 public class SmallPrimesTest {
 
@@ -32,24 +33,24 @@
     public void smallTrialDivision_smallComposite() {
         final List<Integer> factors = new ArrayList<Integer>();
         final int result = SmallPrimes.smallTrialDivision(3*7*23, factors);
-        Assert.assertEquals(1, result);
-        Assert.assertEquals(Arrays.asList(3, 7, 23), factors);
+        Assertions.assertEquals(1, result);
+        Assertions.assertEquals(Arrays.asList(3, 7, 23), factors);
     }
 
     @Test
     public void smallTrialDivision_repeatedFactors() {
         final List<Integer> factors = new ArrayList<Integer>();
         final int result = SmallPrimes.smallTrialDivision(2*2*3*3*3, factors);
-        Assert.assertEquals(1, result);
-        Assert.assertEquals(Arrays.asList(2, 2, 3, 3, 3), factors);
+        Assertions.assertEquals(1, result);
+        Assertions.assertEquals(Arrays.asList(2, 2, 3, 3, 3), factors);
     }
 
     @Test
     public void smallTrialDivision_oneFactor() {
         final List<Integer> factors = new ArrayList<Integer>();
         final int result = SmallPrimes.smallTrialDivision(59, factors);
-        Assert.assertEquals(1, result);
-        Assert.assertEquals(Collections.singletonList(59), factors);
+        Assertions.assertEquals(1, result);
+        Assertions.assertEquals(Collections.singletonList(59), factors);
     }
 
     @Test
@@ -57,77 +58,77 @@
         final List<Integer> factors = new ArrayList<Integer>();
         final int penultimatePrime = SmallPrimes.PRIMES[SmallPrimes.PRIMES.length-2];
         final int result = SmallPrimes.smallTrialDivision(penultimatePrime*SmallPrimes.PRIMES_LAST, factors);
-        Assert.assertEquals(1, result);
-        Assert.assertEquals(Arrays.asList(penultimatePrime, SmallPrimes.PRIMES_LAST), factors);
+        Assertions.assertEquals(1, result);
+        Assertions.assertEquals(Arrays.asList(penultimatePrime, SmallPrimes.PRIMES_LAST), factors);
     }
 
     @Test
     public void smallTrialDivision_largeComposite() {
         final List<Integer> factors = new ArrayList<Integer>();
         final int result = SmallPrimes.smallTrialDivision(2*5*LARGE_PRIME[0], factors);
-        Assert.assertEquals(LARGE_PRIME[0], result);
-        Assert.assertEquals(Arrays.asList(2, 5), factors);
+        Assertions.assertEquals(LARGE_PRIME[0], result);
+        Assertions.assertEquals(Arrays.asList(2, 5), factors);
     }
 
     @Test
     public void smallTrialDivision_noSmallPrimeFactors() {
         final List<Integer> factors = new ArrayList<Integer>();
         final int result = SmallPrimes.smallTrialDivision(LARGE_PRIME[0]*LARGE_PRIME[1], factors);
-        Assert.assertEquals(LARGE_PRIME[0]*LARGE_PRIME[1], result);
-        Assert.assertEquals(Collections.<Integer>emptyList(), factors);
+        Assertions.assertEquals(LARGE_PRIME[0]*LARGE_PRIME[1], result);
+        Assertions.assertEquals(Collections.<Integer>emptyList(), factors);
     }
     
     @Test
     public void boundedTrialDivision_twoDifferentFactors() {
         final List<Integer> factors = new ArrayList<Integer>();
         final int result = SmallPrimes.boundedTrialDivision(LARGE_PRIME[0]*LARGE_PRIME[1], Integer.MAX_VALUE, factors);
-        Assert.assertEquals(LARGE_PRIME[1], result);
-        Assert.assertEquals(Arrays.asList(LARGE_PRIME[0], LARGE_PRIME[1]), factors);
+        Assertions.assertEquals(LARGE_PRIME[1], result);
+        Assertions.assertEquals(Arrays.asList(LARGE_PRIME[0], LARGE_PRIME[1]), factors);
     }
 
     @Test
     public void boundedTrialDivision_square() {
         final List<Integer> factors = new ArrayList<Integer>();
         final int result = SmallPrimes.boundedTrialDivision(LARGE_PRIME[0]*LARGE_PRIME[0], Integer.MAX_VALUE, factors);
-        Assert.assertEquals(LARGE_PRIME[0], result);
-        Assert.assertEquals(Arrays.asList(LARGE_PRIME[0], LARGE_PRIME[0]), factors);
+        Assertions.assertEquals(LARGE_PRIME[0], result);
+        Assertions.assertEquals(Arrays.asList(LARGE_PRIME[0], LARGE_PRIME[0]), factors);
     }
 
     @Test
     public void trialDivision_smallComposite() {
         final List<Integer> factors = SmallPrimes.trialDivision(5*11*29*103);
-        Assert.assertEquals(Arrays.asList(5, 11, 29, 103), factors);
+        Assertions.assertEquals(Arrays.asList(5, 11, 29, 103), factors);
     }
 
     @Test
     public void trialDivision_repeatedFactors() {
         final List<Integer> factors = SmallPrimes.trialDivision(2*2*2*2*5*5);
-        Assert.assertEquals(Arrays.asList(2, 2, 2, 2, 5, 5), factors);
+        Assertions.assertEquals(Arrays.asList(2, 2, 2, 2, 5, 5), factors);
     }
 
     @Test
     public void trialDivision_oneSmallFactor() {
         final List<Integer> factors = SmallPrimes.trialDivision(101);
-        Assert.assertEquals(Collections.singletonList(101), factors);
+        Assertions.assertEquals(Collections.singletonList(101), factors);
     }
 
     @Test
     public void trialDivision_largeComposite() {
         final List<Integer> factors = SmallPrimes.trialDivision(2*3*LARGE_PRIME[0]);
-        Assert.assertEquals(Arrays.asList(2, 3, LARGE_PRIME[0]), factors);
+        Assertions.assertEquals(Arrays.asList(2, 3, LARGE_PRIME[0]), factors);
     }
 
     @Test
     public void trialDivision_veryLargeComposite() {
         final List<Integer> factors = SmallPrimes.trialDivision(2*LARGE_PRIME[0]*LARGE_PRIME[1]);
-        Assert.assertEquals(Arrays.asList(2, LARGE_PRIME[0], LARGE_PRIME[1]), factors);
+        Assertions.assertEquals(Arrays.asList(2, LARGE_PRIME[0], LARGE_PRIME[1]), factors);
     }
 
     @Test
     public void millerRabinPrimeTest_primes() {
         for (final int n : PrimesTest.PRIMES) {
             if (n % 2 == 1) {
-                Assert.assertTrue(SmallPrimes.millerRabinPrimeTest(n));
+                Assertions.assertTrue(SmallPrimes.millerRabinPrimeTest(n));
             }
         }
     }
@@ -136,7 +137,7 @@
     public void millerRabinPrimeTest_composites() {
         for (final int n : PrimesTest.NOT_PRIMES) {
             if (n %2 == 1) {
-                Assert.assertFalse(SmallPrimes.millerRabinPrimeTest(n));
+                Assertions.assertFalse(SmallPrimes.millerRabinPrimeTest(n));
             }
         }
     }
diff --git a/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/QuaternionTest.java b/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/QuaternionTest.java
index f1d96b8..f82e6b7 100644
--- a/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/QuaternionTest.java
+++ b/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/QuaternionTest.java
@@ -18,8 +18,8 @@
 
 import java.util.Random;
 
-import org.junit.Test;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 public class QuaternionTest {
     /** Epsilon for double comparison. */
@@ -29,22 +29,22 @@
 
     @Test
     public void testZeroQuaternion() {
-        Assert.assertEquals(0, Quaternion.ZERO.norm(), 0d);
+        Assertions.assertEquals(0, Quaternion.ZERO.norm(), 0d);
     }
 
     @Test
     public void testUnitQuaternions() {
-        Assert.assertEquals(1, Quaternion.ONE.norm(), 0d);
-        Assert.assertTrue(Quaternion.ONE.normalize() == Quaternion.ONE);
+        Assertions.assertEquals(1, Quaternion.ONE.norm(), 0d);
+        Assertions.assertTrue(Quaternion.ONE.normalize() == Quaternion.ONE);
 
-        Assert.assertEquals(1, Quaternion.I.norm(), 0d);
-        Assert.assertTrue(Quaternion.I.normalize() == Quaternion.I);
+        Assertions.assertEquals(1, Quaternion.I.norm(), 0d);
+        Assertions.assertTrue(Quaternion.I.normalize() == Quaternion.I);
 
-        Assert.assertEquals(1, Quaternion.J.norm(), 0d);
-        Assert.assertTrue(Quaternion.J.normalize() == Quaternion.J);
+        Assertions.assertEquals(1, Quaternion.J.norm(), 0d);
+        Assertions.assertTrue(Quaternion.J.normalize() == Quaternion.J);
 
-        Assert.assertEquals(1, Quaternion.K.norm(), 0d);
-        Assert.assertTrue(Quaternion.K.normalize() == Quaternion.K);
+        Assertions.assertEquals(1, Quaternion.K.norm(), 0d);
+        Assertions.assertTrue(Quaternion.K.normalize() == Quaternion.K);
     }
 
     @Test
@@ -55,10 +55,10 @@
         final double q3 = 0.0005;
         final Quaternion q = Quaternion.of(q0, q1, q2, q3);
 
-        Assert.assertEquals(q0, q.getW(), 0);
-        Assert.assertEquals(q1, q.getX(), 0);
-        Assert.assertEquals(q2, q.getY(), 0);
-        Assert.assertEquals(q3, q.getZ(), 0);
+        Assertions.assertEquals(q0, q.getW(), 0);
+        Assertions.assertEquals(q1, q.getX(), 0);
+        Assertions.assertEquals(q2, q.getY(), 0);
+        Assertions.assertEquals(q3, q.getZ(), 0);
     }
 
     @Test
@@ -72,10 +72,10 @@
         final double sP = q.getScalarPart();
         final double[] vP = q.getVectorPart();
 
-        Assert.assertEquals(q0, sP, 0);
-        Assert.assertEquals(q1, vP[0], 0);
-        Assert.assertEquals(q2, vP[1], 0);
-        Assert.assertEquals(q3, vP[2], 0);
+        Assertions.assertEquals(q0, sP, 0);
+        Assertions.assertEquals(q1, vP[0], 0);
+        Assertions.assertEquals(q2, vP[1], 0);
+        Assertions.assertEquals(q3, vP[2], 0);
     }
 
     @Test
@@ -89,15 +89,17 @@
         final double sP = q.getScalarPart();
         final double[] vP = q.getVectorPart();
 
-        Assert.assertEquals(q0, sP, 0);
-        Assert.assertEquals(q1, vP[0], 0);
-        Assert.assertEquals(q2, vP[1], 0);
-        Assert.assertEquals(q3, vP[2], 0);
+        Assertions.assertEquals(q0, sP, 0);
+        Assertions.assertEquals(q1, vP[0], 0);
+        Assertions.assertEquals(q2, vP[1], 0);
+        Assertions.assertEquals(q3, vP[2], 0);
     }
 
-    @Test(expected=IllegalArgumentException.class)
+    @Test
     public void testWrongDimension() {
-        Quaternion.of(new double[] { 1, 2 });
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> Quaternion.of(new double[] { 1, 2 })
+        );
     }
 
     @Test
@@ -110,10 +112,10 @@
 
         final Quaternion qConjugate = q.conjugate();
 
-        Assert.assertEquals(q0, qConjugate.getW(), 0);
-        Assert.assertEquals(-q1, qConjugate.getX(), 0);
-        Assert.assertEquals(-q2, qConjugate.getY(), 0);
-        Assert.assertEquals(-q3, qConjugate.getZ(), 0);
+        Assertions.assertEquals(q0, qConjugate.getW(), 0);
+        Assertions.assertEquals(-q1, qConjugate.getX(), 0);
+        Assertions.assertEquals(-q2, qConjugate.getY(), 0);
+        Assertions.assertEquals(-q3, qConjugate.getZ(), 0);
     }
 
     /* TODO remove dependency on Vector3D
@@ -224,8 +226,8 @@
         final double actual1 = Quaternion.dot(q1, q2);
         final double actual2 = q1.dot(q2);
 
-        Assert.assertEquals(expected, actual1, EPS);
-        Assert.assertEquals(expected, actual2, EPS);
+        Assertions.assertEquals(expected, actual1, EPS);
+        Assertions.assertEquals(expected, actual2, EPS);
     }
 
     @Test
@@ -241,10 +243,10 @@
 
         final Quaternion q = q1.multiply(a);
 
-        Assert.assertEquals(w, q.getW(), COMPARISON_EPS);
-        Assert.assertEquals(x, q.getX(), COMPARISON_EPS);
-        Assert.assertEquals(y, q.getY(), COMPARISON_EPS);
-        Assert.assertEquals(z, q.getZ(), COMPARISON_EPS);
+        Assertions.assertEquals(w, q.getW(), COMPARISON_EPS);
+        Assertions.assertEquals(x, q.getX(), COMPARISON_EPS);
+        Assertions.assertEquals(y, q.getY(), COMPARISON_EPS);
+        Assertions.assertEquals(z, q.getZ(), COMPARISON_EPS);
     }
 
     @Test
@@ -261,15 +263,15 @@
         final Quaternion qa = Quaternion.add(q1, q2);
         final Quaternion qb = q1.add(q2);
 
-        Assert.assertEquals(w, qa.getW(), EPS);
-        Assert.assertEquals(x, qa.getX(), EPS);
-        Assert.assertEquals(y, qa.getY(), EPS);
-        Assert.assertEquals(z, qa.getZ(), EPS);
+        Assertions.assertEquals(w, qa.getW(), EPS);
+        Assertions.assertEquals(x, qa.getX(), EPS);
+        Assertions.assertEquals(y, qa.getY(), EPS);
+        Assertions.assertEquals(z, qa.getZ(), EPS);
 
-        Assert.assertEquals(w, qb.getW(), EPS);
-        Assert.assertEquals(x, qb.getX(), EPS);
-        Assert.assertEquals(y, qb.getY(), EPS);
-        Assert.assertEquals(z, qb.getZ(), EPS);
+        Assertions.assertEquals(w, qb.getW(), EPS);
+        Assertions.assertEquals(x, qb.getX(), EPS);
+        Assertions.assertEquals(y, qb.getY(), EPS);
+        Assertions.assertEquals(z, qb.getZ(), EPS);
     }
 
     @Test
@@ -286,15 +288,15 @@
         final Quaternion qa = Quaternion.subtract(q1, q2);
         final Quaternion qb = q1.subtract(q2);
 
-        Assert.assertEquals(w, qa.getW(), EPS);
-        Assert.assertEquals(x, qa.getX(), EPS);
-        Assert.assertEquals(y, qa.getY(), EPS);
-        Assert.assertEquals(z, qa.getZ(), EPS);
+        Assertions.assertEquals(w, qa.getW(), EPS);
+        Assertions.assertEquals(x, qa.getX(), EPS);
+        Assertions.assertEquals(y, qa.getY(), EPS);
+        Assertions.assertEquals(z, qa.getZ(), EPS);
 
-        Assert.assertEquals(w, qb.getW(), EPS);
-        Assert.assertEquals(x, qb.getX(), EPS);
-        Assert.assertEquals(y, qb.getY(), EPS);
-        Assert.assertEquals(z, qb.getZ(), EPS);
+        Assertions.assertEquals(w, qb.getW(), EPS);
+        Assertions.assertEquals(x, qb.getX(), EPS);
+        Assertions.assertEquals(y, qb.getY(), EPS);
+        Assertions.assertEquals(z, qb.getZ(), EPS);
 }
 
     @Test
@@ -308,10 +310,10 @@
 
         final double norm = q.norm();
 
-        Assert.assertEquals(Math.sqrt(30), norm, 0);
+        Assertions.assertEquals(Math.sqrt(30), norm, 0);
 
         final double normSquareRef = Quaternion.multiply(q, q.conjugate()).getScalarPart();
-        Assert.assertEquals(Math.sqrt(normSquareRef), norm, 0);
+        Assertions.assertEquals(Math.sqrt(normSquareRef), norm, 0);
     }
 
     @Test
@@ -321,62 +323,71 @@
 
         final Quaternion versor = q.normalize();
 
-        Assert.assertEquals(2.0 / 5.0, versor.getW(), 0);
-        Assert.assertEquals(1.0 / 5.0, versor.getX(), 0);
-        Assert.assertEquals(-4.0 / 5.0, versor.getY(), 0);
-        Assert.assertEquals(-2.0 / 5.0, versor.getZ(), 0);
+        Assertions.assertEquals(2.0 / 5.0, versor.getW(), 0);
+        Assertions.assertEquals(1.0 / 5.0, versor.getX(), 0);
+        Assertions.assertEquals(-4.0 / 5.0, versor.getY(), 0);
+        Assertions.assertEquals(-2.0 / 5.0, versor.getZ(), 0);
 
-        Assert.assertEquals(1, versor.norm(), 0);
+        Assertions.assertEquals(1, versor.norm(), 0);
 
-        Assert.assertTrue(versor.normalize() == versor);
+        Assertions.assertTrue(versor.normalize() == versor);
     }
 
-    @Test(expected=IllegalStateException.class)
+    @Test
     public final void testNormalizeFail_zero() {
         final Quaternion q = Quaternion.of(0, 0, 0, 0);
-        q.normalize();
+        Assertions.assertThrows(IllegalStateException.class,
+                q::normalize
+        );
     }
 
-    @Test(expected=IllegalStateException.class)
+    @Test
     public final void testNormalizeFail_nan() {
         final Quaternion q = Quaternion.of(0, 0, 0, Double.NaN);
-        q.normalize();
+        Assertions.assertThrows(IllegalStateException.class,
+                q::normalize
+        );
+
     }
 
-    @Test(expected=IllegalStateException.class)
+    @Test
     public final void testNormalizeFail_positiveInfinity() {
         final Quaternion q = Quaternion.of(0, 0, Double.POSITIVE_INFINITY, 0);
-        q.normalize();
+        Assertions.assertThrows(IllegalStateException.class,
+                q::normalize
+        );
     }
 
-    @Test(expected=IllegalStateException.class)
+    @Test
     public final void testNormalizeFail_negativeInfinity() {
         final Quaternion q = Quaternion.of(0, Double.NEGATIVE_INFINITY, 0, 0);
-        q.normalize();
+        Assertions.assertThrows(IllegalStateException.class,
+                q::normalize
+        );
     }
 
     @Test
     public final void testObjectEquals() {
         final double one = 1;
         final Quaternion q1 = Quaternion.of(one, one, one, one);
-        Assert.assertTrue(q1.equals(q1));
+        Assertions.assertTrue(q1.equals(q1));
 
         final Quaternion q2 = Quaternion.of(one, one, one, one);
-        Assert.assertTrue(q2.equals(q1));
+        Assertions.assertTrue(q2.equals(q1));
 
         final Quaternion q3 = Quaternion.of(one, Math.nextUp(one), one, one);
-        Assert.assertFalse(q3.equals(q1));
+        Assertions.assertFalse(q3.equals(q1));
 
-        Assert.assertFalse(q3.equals("bar"));
+        Assertions.assertFalse(q3.equals("bar"));
     }
 
     @Test
     public void testHashCode() {
         Quaternion x = Quaternion.of(0.0, 0.0, 0.0, 0.0);
         Quaternion y = Quaternion.of(0.0, 0.0 + Double.MIN_VALUE, 0.0, 0.0);
-        Assert.assertFalse(x.hashCode()==y.hashCode());
+        Assertions.assertFalse(x.hashCode()==y.hashCode());
         y = Quaternion.of(0.0 + Double.MIN_VALUE, 0.0, 0.0, 0.0);
-        Assert.assertFalse(x.hashCode()==y.hashCode());
+        Assertions.assertFalse(x.hashCode()==y.hashCode());
 
         // "equals" and "hashCode" must be compatible: if two objects have
         // different hash codes, "equals" must return false.
@@ -384,23 +395,23 @@
 
         x = Quaternion.of(0.0, 0.0, 0.0, 0.0);
         y = Quaternion.of(-0.0, 0.0, 0.0, 0.0);
-        Assert.assertTrue(x.hashCode() != y.hashCode());
-        Assert.assertFalse(msg, x.equals(y));
+        Assertions.assertTrue(x.hashCode() != y.hashCode());
+        Assertions.assertFalse(x.equals(y), msg);
 
         x = Quaternion.of(0.0, 0.0, 0.0, 0.0);
         y = Quaternion.of(0.0, -0.0, 0.0, 0.0);
-        Assert.assertTrue(x.hashCode() != y.hashCode());
-        Assert.assertFalse(msg, x.equals(y));
+        Assertions.assertTrue(x.hashCode() != y.hashCode());
+        Assertions.assertFalse(x.equals(y), msg);
 
         x = Quaternion.of(0.0, 0.0, 0.0, 0.0);
         y = Quaternion.of(0.0, 0.0, -0.0, 0.0);
-        Assert.assertTrue(x.hashCode() != y.hashCode());
-        Assert.assertFalse(msg, x.equals(y));
+        Assertions.assertTrue(x.hashCode() != y.hashCode());
+        Assertions.assertFalse(x.equals(y), msg);
 
         x = Quaternion.of(0.0, 0.0, 0.0, 0.0);
         y = Quaternion.of(0.0, 0.0, 0.0, -0.0);
-        Assert.assertTrue(x.hashCode() != y.hashCode());
-        Assert.assertFalse(msg, x.equals(y));
+        Assertions.assertTrue(x.hashCode() != y.hashCode());
+        Assertions.assertFalse(x.equals(y), msg);
     }
 
     @Test
@@ -412,15 +423,15 @@
         final Quaternion q4 = Quaternion.of(q1.getW(), q1.getX(), q1.getY() + inc, q1.getZ());
         final Quaternion q5 = Quaternion.of(q1.getW(), q1.getX(), q1.getY(), q1.getZ() + inc);
 
-        Assert.assertFalse(q1.equals(q2, 0.9 * inc));
-        Assert.assertFalse(q1.equals(q3, 0.9 * inc));
-        Assert.assertFalse(q1.equals(q4, 0.9 * inc));
-        Assert.assertFalse(q1.equals(q5, 0.9 * inc));
+        Assertions.assertFalse(q1.equals(q2, 0.9 * inc));
+        Assertions.assertFalse(q1.equals(q3, 0.9 * inc));
+        Assertions.assertFalse(q1.equals(q4, 0.9 * inc));
+        Assertions.assertFalse(q1.equals(q5, 0.9 * inc));
 
-        Assert.assertTrue(q1.equals(q2, 1.1 * inc));
-        Assert.assertTrue(q1.equals(q3, 1.1 * inc));
-        Assert.assertTrue(q1.equals(q4, 1.1 * inc));
-        Assert.assertTrue(q1.equals(q5, 1.1 * inc));
+        Assertions.assertTrue(q1.equals(q2, 1.1 * inc));
+        Assertions.assertTrue(q1.equals(q3, 1.1 * inc));
+        Assertions.assertTrue(q1.equals(q4, 1.1 * inc));
+        Assertions.assertTrue(q1.equals(q5, 1.1 * inc));
     }
 
     @Test
@@ -429,9 +440,9 @@
         final double gap = 1e-5;
         final Quaternion q2 = Quaternion.of(1 + gap, 4 + gap, 2 + gap, 3 + gap);
 
-        Assert.assertTrue(q1.equals(q2, 10 * gap));
-        Assert.assertFalse(q1.equals(q2, gap));
-        Assert.assertFalse(q1.equals(q2, gap / 10));
+        Assertions.assertTrue(q1.equals(q2, 10 * gap));
+        Assertions.assertFalse(q1.equals(q2, gap));
+        Assertions.assertFalse(q1.equals(q2, gap / 10));
     }
 
     @Test
@@ -441,31 +452,31 @@
         for (int i = 0; i < numberOfTrials; i++) {
             final Quaternion q1 = Quaternion.of(r.nextDouble(), r.nextDouble(), r.nextDouble(), r.nextDouble());
             final Quaternion q2 = q1.normalize();
-            Assert.assertTrue(q2.isUnit(COMPARISON_EPS));
+            Assertions.assertTrue(q2.isUnit(COMPARISON_EPS));
         }
 
         final Quaternion q = Quaternion.of(1, 1, 1, 1);
-        Assert.assertFalse(q.isUnit(COMPARISON_EPS));
+        Assertions.assertFalse(q.isUnit(COMPARISON_EPS));
     }
 
     @Test
     public final void testIsPure() {
         final Quaternion q1 = Quaternion.of(0, 5, 4, 8);
-        Assert.assertTrue(q1.isPure(EPS));
+        Assertions.assertTrue(q1.isPure(EPS));
 
         final Quaternion q2 = Quaternion.of(0 - EPS, 5, 4, 8);
-        Assert.assertTrue(q2.isPure(EPS));
+        Assertions.assertTrue(q2.isPure(EPS));
 
         final Quaternion q3 = Quaternion.of(0 - 1.1 * EPS, 5, 4, 8);
-        Assert.assertFalse(q3.isPure(EPS));
+        Assertions.assertFalse(q3.isPure(EPS));
 
         final Random r = new Random(48);
         final double[] v = {r.nextDouble(), r.nextDouble(), r.nextDouble()};
         final Quaternion q4 = Quaternion.of(v);
-        Assert.assertTrue(q4.isPure(0));
+        Assertions.assertTrue(q4.isPure(0));
 
         final Quaternion q5 = Quaternion.of(0, v);
-        Assert.assertTrue(q5.isPure(0));
+        Assertions.assertTrue(q5.isPure(0));
     }
 
     @Test
@@ -474,7 +485,7 @@
         Quaternion expected = Quaternion.of(0.5, -0.5, -0.5, 0.5);
         assertEquals(q, expected, EPS);
 
-        Assert.assertTrue(q.positivePolarForm() == q);
+        Assertions.assertTrue(q.positivePolarForm() == q);
     }
 
     @Test
@@ -483,23 +494,23 @@
         Quaternion expected = Quaternion.of(0.5, -0.5, 0.5, -0.5);
         assertEquals(q, expected, EPS);
 
-        Assert.assertTrue(q.positivePolarForm() == q);
+        Assertions.assertTrue(q.positivePolarForm() == q);
     }
 
     @Test
     public final void testPositivePolarFormWhenScalarPositiveAndNormalized() {
         Quaternion q = Quaternion.of(123, 45, 67, 89).normalize().positivePolarForm();
 
-        Assert.assertTrue(q.getW() >= 0);
-        Assert.assertTrue(q.positivePolarForm() == q);
+        Assertions.assertTrue(q.getW() >= 0);
+        Assertions.assertTrue(q.positivePolarForm() == q);
     }
 
     @Test
     public final void testPositivePolarFormWhenScalarNegativeAndNormalized() {
         Quaternion q = Quaternion.of(123, 45, 67, 89).normalize().negate().positivePolarForm();
 
-        Assert.assertTrue(q.getW() >= 0);
-        Assert.assertTrue(q.positivePolarForm() == q);
+        Assertions.assertTrue(q.getW() >= 0);
+        Assertions.assertTrue(q.positivePolarForm() == q);
     }
 
     @Test
@@ -510,12 +521,12 @@
         final double d = 4;
         final Quaternion q = Quaternion.of(a, b, c, d);
         final Quaternion qNeg = q.negate();
-        Assert.assertEquals(-a, qNeg.getW(), 0d);
-        Assert.assertEquals(-b, qNeg.getX(), 0d);
-        Assert.assertEquals(-c, qNeg.getY(), 0d);
-        Assert.assertEquals(-d, qNeg.getZ(), 0d);
+        Assertions.assertEquals(-a, qNeg.getW(), 0d);
+        Assertions.assertEquals(-b, qNeg.getX(), 0d);
+        Assertions.assertEquals(-c, qNeg.getY(), 0d);
+        Assertions.assertEquals(-d, qNeg.getZ(), 0d);
 
-        Assert.assertTrue(q.equals(qNeg.negate(), 0d));
+        Assertions.assertTrue(q.equals(qNeg.negate(), 0d));
     }
 
     @Test
@@ -526,7 +537,7 @@
         final double d = 4;
         final Quaternion q = Quaternion.of(a, b, c, d).normalize();
         final Quaternion qNeg = q.negate();
-        Assert.assertTrue(q.equals(qNeg.negate(), 0d));
+        Assertions.assertTrue(q.equals(qNeg.negate(), 0d));
     }
 
     @Test
@@ -537,7 +548,7 @@
         final double d = 4;
         final Quaternion q = Quaternion.of(a, b, c, d).positivePolarForm();
         final Quaternion qNeg = q.negate();
-        Assert.assertTrue(q.equals(qNeg.negate(), 0d));
+        Assertions.assertTrue(q.equals(qNeg.negate(), 0d));
     }
 
     /* TODO remove dependency on Rotation
@@ -574,48 +585,56 @@
         final Quaternion q = Quaternion.of(1.5, 4, 2, -2.5);
 
         final Quaternion inverseQ = q.inverse();
-        Assert.assertEquals(1.5 / 28.5, inverseQ.getW(), 0);
-        Assert.assertEquals(-4.0 / 28.5, inverseQ.getX(), 0);
-        Assert.assertEquals(-2.0 / 28.5, inverseQ.getY(), 0);
-        Assert.assertEquals(2.5 / 28.5, inverseQ.getZ(), 0);
+        Assertions.assertEquals(1.5 / 28.5, inverseQ.getW(), 0);
+        Assertions.assertEquals(-4.0 / 28.5, inverseQ.getX(), 0);
+        Assertions.assertEquals(-2.0 / 28.5, inverseQ.getY(), 0);
+        Assertions.assertEquals(2.5 / 28.5, inverseQ.getZ(), 0);
 
         final Quaternion product = Quaternion.multiply(inverseQ, q);
-        Assert.assertEquals(1, product.getW(), EPS);
-        Assert.assertEquals(0, product.getX(), EPS);
-        Assert.assertEquals(0, product.getY(), EPS);
-        Assert.assertEquals(0, product.getZ(), EPS);
+        Assertions.assertEquals(1, product.getW(), EPS);
+        Assertions.assertEquals(0, product.getX(), EPS);
+        Assertions.assertEquals(0, product.getY(), EPS);
+        Assertions.assertEquals(0, product.getZ(), EPS);
 
         final Quaternion qNul = Quaternion.of(0, 0, 0, 0);
         try {
             final Quaternion inverseQNul = qNul.inverse();
-            Assert.fail("expecting ZeroException but got : " + inverseQNul);
+            Assertions.fail("expecting ZeroException but got : " + inverseQNul);
         } catch (IllegalStateException ex) {
             // expected
         }
     }
 
-    @Test(expected=IllegalStateException.class)
+    @Test
     public void testInverse_zeroNorm() {
         Quaternion q = Quaternion.of(0, 0, 0, 0);
-        q.inverse();
+        Assertions.assertThrows(IllegalStateException.class,
+                q::inverse
+        );
     }
 
-    @Test(expected=IllegalStateException.class)
+    @Test
     public void testInverse_nanNorm() {
         Quaternion q = Quaternion.of(Double.NaN, 0, 0, 0);
-        q.inverse();
+        Assertions.assertThrows(IllegalStateException.class,
+                q::inverse
+        );
     }
 
-    @Test(expected=IllegalStateException.class)
+    @Test
     public void testInverse_positiveInfinityNorm() {
         Quaternion q = Quaternion.of(0, Double.POSITIVE_INFINITY, 0, 0);
-        q.inverse();
+        Assertions.assertThrows(IllegalStateException.class,
+                q::inverse
+        );
     }
 
-    @Test(expected=IllegalStateException.class)
+    @Test
     public void testInverse_negativeInfinityNorm() {
         Quaternion q = Quaternion.of(0, 0, Double.NEGATIVE_INFINITY, 0);
-        q.inverse();
+        Assertions.assertThrows(IllegalStateException.class,
+                q::inverse
+        );
     }
 
     @Test
@@ -623,7 +642,7 @@
         final Quaternion invQ = Quaternion.of(-1.2, 3.4, -5.6, -7.8).normalize().inverse();
         final Quaternion q = invQ.inverse();
         final Quaternion result = q.multiply(invQ);
-        Assert.assertTrue(result.toString(), Quaternion.ONE.equals(result, EPS));
+        Assertions.assertTrue(Quaternion.ONE.equals(result, EPS), result.toString());
     }
 
     @Test
@@ -631,7 +650,7 @@
         final Quaternion invQ = Quaternion.of(1.2, -3.4, 5.6, -7.8).positivePolarForm().inverse();
         final Quaternion q = invQ.inverse();
         final Quaternion result = q.multiply(invQ);
-        Assert.assertTrue(result.toString(), Quaternion.ONE.equals(result, EPS));
+        Assertions.assertTrue(Quaternion.ONE.equals(result, EPS), result.toString());
     }
 
     @Test
@@ -657,51 +676,65 @@
     @Test
     public final void testParseSpecials() {
         Quaternion parsed = Quaternion.parse("[1e-5 Infinity NaN -0xa.cp0]");
-        Assert.assertEquals(1e-5, parsed.getW(), EPS);
-        Assert.assertTrue(Double.isInfinite(parsed.getX()));
-        Assert.assertTrue(Double.isNaN(parsed.getY()));
-        Assert.assertEquals(-0xa.cp0, parsed.getZ(), EPS);
+        Assertions.assertEquals(1e-5, parsed.getW(), EPS);
+        Assertions.assertTrue(Double.isInfinite(parsed.getX()));
+        Assertions.assertTrue(Double.isNaN(parsed.getY()));
+        Assertions.assertEquals(-0xa.cp0, parsed.getZ(), EPS);
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     public final void testParseMissingStart() {
-        Quaternion.parse("1.0 2.0 3.0 4.0]");
+        Assertions.assertThrows(IllegalArgumentException.class,
+            () -> Quaternion.parse("1.0 2.0 3.0 4.0]")
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     public final void testParseMissingEnd() {
-        Quaternion.parse("[1.0 2.0 3.0 4.0");
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> Quaternion.parse("[1.0 2.0 3.0 4.0")
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     public final void testParseMissingPart() {
-        Quaternion.parse("[1.0 2.0 3.0 ]");
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> Quaternion.parse("[1.0 2.0 3.0 ]")
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     public final void testParseInvalidScalar() {
-        Quaternion.parse("[1.x 2.0 3.0 4.0]");
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> Quaternion.parse("[1.x 2.0 3.0 4.0]")
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     public final void testParseInvalidI() {
-        Quaternion.parse("[1.0 2.0x 3.0 4.0]");
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> Quaternion.parse("[1.0 2.0x 3.0 4.0]")
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     public final void testParseInvalidJ() {
-        Quaternion.parse("[1.0 2.0 3.0x 4.0]");
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> Quaternion.parse("[1.0 2.0 3.0x 4.0]")
+        );
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     public final void testParseInvalidK() {
-        Quaternion.parse("[1.0 2.0 3.0 4.0x]");
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> Quaternion.parse("[1.0 2.0 3.0 4.0x]")
+        );
     }
 
     @Test
     public final void testToString() {
         final Quaternion q = Quaternion.of(1, 2, 3, 4);
-        Assert.assertEquals("[1.0 2.0 3.0 4.0]", q.toString());
+        Assertions.assertEquals("[1.0 2.0 3.0 4.0]", q.toString());
     }
 
     /**
@@ -711,7 +744,7 @@
      * @param tolerance
      */
     private void assertEquals(Quaternion actual, Quaternion expected, double tolerance) {
-        Assert.assertTrue("expecting " + expected + " but got " + actual, actual.equals(expected, tolerance));
+        Assertions.assertTrue(actual.equals(expected, tolerance), "expecting " + expected + " but got " + actual);
     }
 
 }
diff --git a/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/SlerpTest.java b/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/SlerpTest.java
index ef9e013..e6b7719 100644
--- a/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/SlerpTest.java
+++ b/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/SlerpTest.java
@@ -17,8 +17,9 @@
 package org.apache.commons.numbers.quaternion;
 
 import org.apache.commons.numbers.core.Precision;
-import org.junit.Assert;
-import org.junit.Test;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 public class SlerpTest {
 
@@ -62,8 +63,8 @@
             Quaternion result = slerp.apply(t);
 
             // assert
-            Assert.assertEquals(1.0, result.norm(), EPS);
-            Assert.assertTrue(result.getW() >= 0.0);
+            Assertions.assertEquals(1.0, result.norm(), EPS);
+            Assertions.assertTrue(result.getW() >= 0.0);
         }
     }
 
@@ -116,8 +117,8 @@
             Quaternion result = slerp.apply(t);
 
             // assert
-            Assert.assertEquals(1.0, result.norm(), EPS);
-            Assert.assertTrue(result.getW() >= 0.0);
+            Assertions.assertEquals(1.0, result.norm(), EPS);
+            Assertions.assertTrue(result.getW() >= 0.0);
         }
     }
 
@@ -146,7 +147,7 @@
         Slerp slerp = new Slerp(q1, q2);
 
         // act/assert
-        Assert.assertEquals(-1.0, q1.dot(q2), EPS);
+        Assertions.assertEquals(-1.0, q1.dot(q2), EPS);
 
         Quaternion expected = q1.positivePolarForm();
 
@@ -184,19 +185,19 @@
         double[] vec = { 2, 0, 1 };
 
         // act/assert
-        Assert.assertArrayEquals(new double[] { 2, 0, 1 },
+        Assertions.assertArrayEquals(new double[] { 2, 0, 1 },
                 transformVector(slerp.apply(0), vec), EPS);
 
-        Assert.assertArrayEquals(new double[] { SQRT_2, SQRT_2, 1 },
+        Assertions.assertArrayEquals(new double[] { SQRT_2, SQRT_2, 1 },
                 transformVector(slerp.apply(0.25), vec), EPS);
 
-        Assert.assertArrayEquals(new double[] { 0, 2, 1 },
+        Assertions.assertArrayEquals(new double[] { 0, 2, 1 },
                 transformVector(slerp.apply(0.5), vec), EPS);
 
-        Assert.assertArrayEquals(new double[] { -SQRT_2, SQRT_2, 1 },
+        Assertions.assertArrayEquals(new double[] { -SQRT_2, SQRT_2, 1 },
                 transformVector(slerp.apply(0.75), vec), EPS);
 
-        Assert.assertArrayEquals(new double[] { -2, 0, 1 },
+        Assertions.assertArrayEquals(new double[] { -2, 0, 1 },
                 transformVector(slerp.apply(1), vec), EPS);
     }
 
@@ -254,8 +255,8 @@
         double[] endVec = transformVector(end, vec);
 
         // check start and end values
-        Assert.assertArrayEquals(startVec, transformVector(slerp.apply(0), vec), EPS);
-        Assert.assertArrayEquals(endVec, transformVector(slerp.apply(1), vec), EPS);
+        Assertions.assertArrayEquals(startVec, transformVector(slerp.apply(0), vec), EPS);
+        Assertions.assertArrayEquals(endVec, transformVector(slerp.apply(1), vec), EPS);
 
         // check intermediate values
         double prevAngle = -1;
@@ -268,13 +269,13 @@
             double[] slerpVec = transformVector(result, vec);
 
             // the transformation should not effect the vector magnitude
-            Assert.assertEquals(vecNorm, norm(slerpVec), EPS);
+            Assertions.assertEquals(vecNorm, norm(slerpVec), EPS);
 
             // make sure that we're steadily progressing to the end angle
             double angle = angle(slerpVec, startVec);
-            Assert.assertTrue("Expected slerp angle to continuously increase; previous angle was " +
-                  prevAngle + " and new angle is " + angle,
-                  Precision.compareTo(angle, prevAngle, EPS) >= 0);
+            Assertions.assertTrue(Precision.compareTo(angle, prevAngle, EPS) >= 0,
+                    "Expected slerp angle to continuously increase; previous angle was " +
+                            prevAngle + " and new angle is " + angle);
         }
     }
 
@@ -294,16 +295,16 @@
 
         // act/assert
         Slerp slerp12 = new Slerp(q1, q2);
-        Assert.assertArrayEquals(new double[] { 1, 0, 0 }, transformVector(slerp12.apply(-4.5), vec), EPS);
-        Assert.assertArrayEquals(new double[] { 1, 0, 0 }, transformVector(slerp12.apply(-0.5), vec), EPS);
-        Assert.assertArrayEquals(new double[] { -1, 0, 0 }, transformVector(slerp12.apply(1.5), vec), EPS);
-        Assert.assertArrayEquals(new double[] { -1, 0, 0 }, transformVector(slerp12.apply(5.5), vec), EPS);
+        Assertions.assertArrayEquals(new double[] { 1, 0, 0 }, transformVector(slerp12.apply(-4.5), vec), EPS);
+        Assertions.assertArrayEquals(new double[] { 1, 0, 0 }, transformVector(slerp12.apply(-0.5), vec), EPS);
+        Assertions.assertArrayEquals(new double[] { -1, 0, 0 }, transformVector(slerp12.apply(1.5), vec), EPS);
+        Assertions.assertArrayEquals(new double[] { -1, 0, 0 }, transformVector(slerp12.apply(5.5), vec), EPS);
 
         Slerp slerp21 = new Slerp(q2, q1);
-        Assert.assertArrayEquals(new double[] { -1, 0, 0 }, transformVector(slerp21.apply(-4.5), vec), EPS);
-        Assert.assertArrayEquals(new double[] { -1, 0, 0 }, transformVector(slerp21.apply(-0.5), vec), EPS);
-        Assert.assertArrayEquals(new double[] { 1, 0, 0 }, transformVector(slerp21.apply(1.5), vec), EPS);
-        Assert.assertArrayEquals(new double[] { 1, 0, 0 }, transformVector(slerp21.apply(5.5), vec), EPS);
+        Assertions.assertArrayEquals(new double[] { -1, 0, 0 }, transformVector(slerp21.apply(-4.5), vec), EPS);
+        Assertions.assertArrayEquals(new double[] { -1, 0, 0 }, transformVector(slerp21.apply(-0.5), vec), EPS);
+        Assertions.assertArrayEquals(new double[] { 1, 0, 0 }, transformVector(slerp21.apply(1.5), vec), EPS);
+        Assertions.assertArrayEquals(new double[] { 1, 0, 0 }, transformVector(slerp21.apply(5.5), vec), EPS);
     }
 
     /**
@@ -381,9 +382,9 @@
     private static void assertQuaternion(Quaternion expected, Quaternion actual) {
         String msg = "Expected quaternion to equal " + expected + " but was " + actual;
 
-        Assert.assertEquals(msg, expected.getW(), actual.getW(), EPS);
-        Assert.assertEquals(msg, expected.getX(), actual.getX(), EPS);
-        Assert.assertEquals(msg, expected.getY(), actual.getY(), EPS);
-        Assert.assertEquals(msg, expected.getZ(), actual.getZ(), EPS);
+        Assertions.assertEquals(expected.getW(), actual.getW(), EPS, msg);
+        Assertions.assertEquals(expected.getX(), actual.getX(), EPS, msg);
+        Assertions.assertEquals(expected.getY(), actual.getY(), EPS, msg);
+        Assertions.assertEquals(expected.getZ(), actual.getZ(), EPS, msg);
     }
 }