This is an automated email from the ASF dual-hosted git repository. erans pushed a commit to branch master in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit 19c13db6bd1b5ca7ddcf6e5a86252bae5c30ec08 Author: Schamschi <[email protected]> AuthorDate: Tue Jun 18 23:51:44 2019 +0200 NUMBERS-117: Remove redundant methods in org.apache.commons.numbers.complex.streams.TestUtils Remove the following methods: assertEquals(double, double, double) assertEquals(String, double, double, double) assertSame(double[], double[]) assertSame(float[], float[]) assertSame(double, double) assertEquals(String, double[], double[], double) assertEquals(String, float[], float[], float) equalsIncludingNaN(double, double, double) Remove the following private method that became unused after the removal of the above methods: equalsIncludingNaN(double, double) --- .../numbers/complex/streams/ComplexUtilsTest.java | 36 +++--- .../commons/numbers/complex/streams/TestUtils.java | 128 +-------------------- 2 files changed, 24 insertions(+), 140 deletions(-) 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 fb8f4d7..daaa2e5 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 @@ -379,27 +379,27 @@ public class ComplexUtilsTest { // Extract complex from real float array, index 3 TestUtils.assertSame(Complex.ofCartesian(0, 3), ComplexUtils.extractComplexFromImaginaryArray(f, 3)); // Extract real double from complex array, index 3 - TestUtils.assertSame(6, ComplexUtils.extractRealFromComplexArray(c, 3)); + Assertions.assertEquals(6, ComplexUtils.extractRealFromComplexArray(c, 3)); // Extract real float from complex array, index 3 - TestUtils.assertSame(6, ComplexUtils.extractRealFloatFromComplexArray(c, 3)); + Assertions.assertEquals(6, ComplexUtils.extractRealFloatFromComplexArray(c, 3)); // Extract real double from complex array, index 3 - TestUtils.assertSame(7, ComplexUtils.extractImaginaryFromComplexArray(c, 3)); + Assertions.assertEquals(7, ComplexUtils.extractImaginaryFromComplexArray(c, 3)); // Extract real float from complex array, index 3 - TestUtils.assertSame(7, ComplexUtils.extractImaginaryFloatFromComplexArray(c, 3)); + Assertions.assertEquals(7, ComplexUtils.extractImaginaryFloatFromComplexArray(c, 3)); // Extract complex from interleaved double array, index 3 TestUtils.assertSame(Complex.ofCartesian(6, 7), ComplexUtils.extractComplexFromInterleavedArray(d, 3)); // Extract interleaved double array from complex array, index 3 - TestUtils.assertSame(new double[]{6d, 7d}, ComplexUtils.extractInterleavedFromComplexArray(c, 3)); + Assertions.assertArrayEquals(new double[]{6d, 7d}, ComplexUtils.extractInterleavedFromComplexArray(c, 3)); // Extract interleaved float array from complex array, index 3 - TestUtils.assertSame(new float[]{6f, 7f}, ComplexUtils.extractInterleavedFloatFromComplexArray(c, 3)); + Assertions.assertArrayEquals(new float[]{6f, 7f}, ComplexUtils.extractInterleavedFloatFromComplexArray(c, 3)); // Extract complex from interleaved float array, index 3 TestUtils.assertSame(Complex.ofCartesian(6, 7), ComplexUtils.extractComplexFromInterleavedArray(f, 3)); // Extract interleaved double from complex array, index 3 - TestUtils.assertEquals(msg, new double[] { 6, 7 }, ComplexUtils.extractInterleavedFromComplexArray(c, 3), - Math.ulp(1)); + Assertions.assertArrayEquals(new double[] { 6, 7 }, ComplexUtils.extractInterleavedFromComplexArray(c, 3), + Math.ulp(1), msg); // Extract interleaved float from complex array, index 3 - TestUtils.assertEquals(msg, new double[] { 6, 7 }, ComplexUtils.extractInterleavedFromComplexArray(c, 3), - Math.ulp(1)); + Assertions.assertArrayEquals(new double[] { 6, 7 }, ComplexUtils.extractInterleavedFromComplexArray(c, 3), + Math.ulp(1), msg); } // REAL <-> COMPLEX @@ -427,9 +427,9 @@ public class ComplexUtilsTest { public void testComplexToReal() { setArrays(); // Real complex to double, whole array - TestUtils.assertEquals(msg, sr, ComplexUtils.complex2Real(c), Math.ulp(1.0)); + Assertions.assertArrayEquals(sr, ComplexUtils.complex2Real(c), Math.ulp(1.0), msg); // Real complex to float, whole array - TestUtils.assertEquals(msg, sfr, ComplexUtils.complex2RealFloat(c), Math.ulp(1.0f)); + Assertions.assertArrayEquals(sfr, ComplexUtils.complex2RealFloat(c), Math.ulp(1.0f), msg); // 2d TestUtils.assertEquals(msg, sr2d, ComplexUtils.complex2Real(cr2d), 0); @@ -468,9 +468,9 @@ public class ComplexUtilsTest { public void testComplexToImaginary() { setArrays(); // Imaginary complex to double, whole array - TestUtils.assertEquals(msg, si, ComplexUtils.complex2Imaginary(c), Math.ulp(1.0)); + Assertions.assertArrayEquals(si, ComplexUtils.complex2Imaginary(c), Math.ulp(1.0), msg); // Imaginary complex to float, whole array - TestUtils.assertEquals(msg, sfi, ComplexUtils.complex2ImaginaryFloat(c), Math.ulp(1.0f)); + Assertions.assertArrayEquals(sfi, ComplexUtils.complex2ImaginaryFloat(c), Math.ulp(1.0f), msg); // 2d TestUtils.assertEquals(msg, si2d, ComplexUtils.complex2Imaginary(ci2d), 0); @@ -669,9 +669,9 @@ public class ComplexUtilsTest { @Test public void testComplexToInterleaved() { setArrays(); - TestUtils.assertEquals(msg, di, ComplexUtils.complex2Interleaved(c), Math.ulp(1.0)); + Assertions.assertArrayEquals(di, ComplexUtils.complex2Interleaved(c), Math.ulp(1.0), msg); // Interleaved complex to float, whole array - TestUtils.assertEquals(msg, fi, ComplexUtils.complex2InterleavedFloat(c), Math.ulp(1.0f)); + Assertions.assertArrayEquals(fi, ComplexUtils.complex2InterleavedFloat(c), Math.ulp(1.0f), msg); // 2d TestUtils.assertEquals(msg, di2d0, ComplexUtils.complex2Interleaved(c2d, 0), 0); @@ -756,7 +756,7 @@ public class ComplexUtilsTest { double[] observed = ComplexUtils.abs(c); Assertions.assertEquals(c.length, observed.length); for (int i = 0; i < c.length; i++) { - TestUtils.assertEquals(c[i].abs(), observed[i], 0); + Assertions.assertEquals(c[i].abs(), observed[i], 0); } } @@ -766,7 +766,7 @@ public class ComplexUtilsTest { double[] observed = ComplexUtils.arg(c); Assertions.assertEquals(c.length, observed.length); for (int i = 0; i < c.length; i++) { - TestUtils.assertEquals(c[i].getArgument(), observed[i], 0); + Assertions.assertEquals(c[i].getArgument(), observed[i], 0); } } } diff --git a/commons-numbers-complex-streams/src/test/java/org/apache/commons/numbers/complex/streams/TestUtils.java b/commons-numbers-complex-streams/src/test/java/org/apache/commons/numbers/complex/streams/TestUtils.java index 92088e5..30de90e 100644 --- a/commons-numbers-complex-streams/src/test/java/org/apache/commons/numbers/complex/streams/TestUtils.java +++ b/commons-numbers-complex-streams/src/test/java/org/apache/commons/numbers/complex/streams/TestUtils.java @@ -35,44 +35,6 @@ class TestUtils { } /** - * Verifies that expected and actual are within delta, or are both NaN or - * infinities of the same sign. - */ - public static void assertEquals(double expected, double actual, double delta) { - assertEquals(null, expected, actual, delta); - } - - /** - * Verifies that expected and actual are within delta, or are both NaN or - * infinities of the same sign. - */ - public static void assertEquals(String msg, double expected, double actual, double delta) { - // check for NaN - if(Double.isNaN(expected)){ - Assertions.assertTrue(Double.isNaN(actual), - (msg == null ? "" : msg + "\n") + actual + " is not NaN."); - } else { - Assertions.assertEquals(expected, actual, delta, msg); - } - } - - /** - * Verifies that the two arguments are exactly the same, either - * both NaN or infinities of same sign, or identical floating point values. - */ - public static void assertSame(double[] expected, double[] actual) { - assertEquals("", expected, actual, 0); - } - - /** - * Verifies that the two arguments are exactly the same, either - * both NaN or infinities of same sign, or identical floating point values. - */ - public static void assertSame(float[] expected, float[] actual) { - assertEquals("", expected, actual, 0); - } - - /** * Verifies that the two arguments are exactly the same, either * both NaN or infinities of same sign, or identical floating point values. */ @@ -105,20 +67,12 @@ class TestUtils { } /** - * Verifies that the two arguments are exactly the same, either - * both NaN or infinities of same sign, or identical floating point values. - */ - public static void assertSame(double expected, double actual) { - Assertions.assertEquals(expected, actual, 0); - } - - /** * Verifies that real and imaginary parts of the two complex arguments * are exactly the same. Also ensures that NaN / infinite components match. */ public static void assertSame(Complex expected, Complex actual) { - assertSame(expected.getReal(), actual.getReal()); - assertSame(expected.getImaginary(), actual.getImaginary()); + Assertions.assertEquals(expected.getReal(), actual.getReal()); + Assertions.assertEquals(expected.getImaginary(), actual.getImaginary()); } /** @@ -130,32 +84,11 @@ class TestUtils { Assertions.assertEquals(expected.getImaginary(), actual.getImaginary(), delta, "Imaginary Values Differ"); } - /** verifies that two arrays are close (sup norm) */ - public static void assertEquals(String msg, double[] expected, double[] observed, double tolerance) { - assertArrayLengthsEqual(msg, expected.length, observed.length); - StringBuilder out = new StringBuilder(msg); - boolean failure = false; - for (int i=0; i < expected.length; i++) { - if (!equalsIncludingNaN(expected[i], observed[i], tolerance)) { - failure = true; - out.append("\n[").append(i).append("] "); - out.append("Elements differ. "); - out.append(" expected = "); - out.append(expected[i]); - out.append(" observed = "); - out.append(observed[i]); - } - } - if (failure) { - Assertions.fail(out.toString()); - } - } - /** verifies that two 2D arrays are close (sup norm) */ public static void assertEquals(String msg, double[][] expected, double[][] observed, double tolerance) { assertArrayLengthsEqual(msg, expected.length, observed.length); for (int i=0; i < expected.length; i++) { - assertEquals(msg + "[" + i + "]", expected[i], observed[i], tolerance); + Assertions.assertArrayEquals(expected[i], observed[i], tolerance, msg + "[" + i + "]"); } } @@ -183,32 +116,11 @@ class TestUtils { } } - /** verifies that two arrays are close (sup norm) */ - public static void assertEquals(String msg, float[] expected, float[] observed, float tolerance) { - assertArrayLengthsEqual(msg, expected.length, observed.length); - StringBuilder out = new StringBuilder(msg); - boolean failure = false; - for (int i=0; i < expected.length; i++) { - if (!equalsIncludingNaN(expected[i], observed[i], tolerance)) { - failure = true; - out.append("\n[").append(i).append("] "); - out.append("Elements differ. "); - out.append(" expected = "); - out.append(expected[i]); - out.append(" observed = "); - out.append(observed[i]); - } - } - if (failure) { - Assertions.fail(out.toString()); - } - } - /** verifies that two 2D arrays are close (sup norm) */ public static void assertEquals(String msg, float[][] expected, float[][] observed, float tolerance) { assertArrayLengthsEqual(msg, expected.length, observed.length); for (int i=0; i < expected.length; i++) { - assertEquals(msg + "[" + i + "]", expected[i], observed[i], tolerance); + Assertions.assertArrayEquals(expected[i], observed[i], tolerance, msg + "[" + i + "]"); } } @@ -226,7 +138,7 @@ class TestUtils { StringBuilder out = new StringBuilder(msg); boolean failure = false; for (int i=0; i < expected.length; i++) { - if (!equalsIncludingNaN(expected[i].getReal(), observed[i].getReal(), tolerance)) { + if (!Precision.equalsIncludingNaN(expected[i].getReal(), observed[i].getReal(), tolerance)) { failure = true; out.append("\n[").append(i).append("] "); out.append("Real elements differ. "); @@ -235,7 +147,7 @@ class TestUtils { out.append(" observed = "); out.append(observed[i].getReal()); } - if (!equalsIncludingNaN(expected[i].getImaginary(), observed[i].getImaginary(), tolerance)) { + if (!Precision.equalsIncludingNaN(expected[i].getImaginary(), observed[i].getImaginary(), tolerance)) { failure = true; out.append("\n[").append(i).append("] "); out.append("Imaginary elements differ. "); @@ -275,34 +187,6 @@ class TestUtils { } /** - * Returns true if the arguments are both NaN, are equal or are within the range - * of allowed error (inclusive). - * - * @param x first value - * @param y second value - * @param eps the amount of absolute error to allow. - * @return {@code true} if the values are equal or within range of each other, - * or both are NaN. - * - */ - private static boolean equalsIncludingNaN(double x, double y, double eps) { - return equalsIncludingNaN(x, y) || (Math.abs(y - x) <= eps); - } - - /** - * Returns true if the arguments are both NaN or they are - * equal as defined by {@link Precision#equals(double,double) equals(x, y, 1)}. - * - * @param x first value - * @param y second value - * @return {@code true} if the values are equal or both are NaN. - * - */ - private static boolean equalsIncludingNaN(double x, double y) { - return (x != x || y != y) ? !(x != x ^ y != y) : Precision.equals(x, y, 1); - } - - /** * Assert that the given array lengths are the same * @param msg Initial message * @param expectedLength expected array length
