You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by er...@apache.org on 2019/06/18 23:02:29 UTC
[commons-numbers] 02/04: NUMBERS-117: Remove redundant methods in
org.apache.commons.numbers.complex.streams.TestUtils
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 <he...@gmx.at>
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