harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From telli...@apache.org
Subject svn commit: r360107 - in /incubator/harmony/enhanced/classlib/trunk/java-src/luni/src: main/java/java/lang/ main/java/java/util/ test/java/org/apache/harmony/tests/java/util/
Date Fri, 30 Dec 2005 15:35:50 GMT
Author: tellison
Date: Fri Dec 30 07:35:40 2005
New Revision: 360107

URL: http://svn.apache.org/viewcvs?rev=360107&view=rev
Log:
Fixes and regression test for HARMONY-22 (Double NaN should compare greater than
positive infinity) including equivalent changes required in Float, and in the sort
ordering of float and double arrays by java.util.Arrays

Added:
    incubator/harmony/enhanced/classlib/trunk/java-src/luni/src/test/java/org/apache/harmony/tests/java/util/
    incubator/harmony/enhanced/classlib/trunk/java-src/luni/src/test/java/org/apache/harmony/tests/java/util/ArraysTest.java
Modified:
    incubator/harmony/enhanced/classlib/trunk/java-src/luni/src/main/java/java/lang/Double.java
    incubator/harmony/enhanced/classlib/trunk/java-src/luni/src/main/java/java/lang/Float.java
    incubator/harmony/enhanced/classlib/trunk/java-src/luni/src/main/java/java/util/Arrays.java

Modified: incubator/harmony/enhanced/classlib/trunk/java-src/luni/src/main/java/java/lang/Double.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/java-src/luni/src/main/java/java/lang/Double.java?rev=360107&r1=360106&r2=360107&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/java-src/luni/src/main/java/java/lang/Double.java
(original)
+++ incubator/harmony/enhanced/classlib/trunk/java-src/luni/src/main/java/java/lang/Double.java
Fri Dec 30 07:35:40 2005
@@ -83,18 +83,37 @@
 	}
 
 	/**
-	 * Compares the receiver with the Double parameter.
+	 * Compares the receiver with the Double parameter. NaN is equal to NaN, and
+	 * is greater than other double values. 0d is greater than -0d.
 	 * 
 	 * @param object
 	 *            the Double to compare to the receiver
 	 * 
-	 * @return Returns greater than zero when this.doubleValue() >
-	 *         object.doubleValue(), zero when this.doubleValue() ==
-	 *         object.doubleValue(), and less than zero when this.doubleValue() <
-	 *         object.doubleValue()
+	 * @return Returns greater than zero when this.doubleValue() is greater than
+	 *         object.doubleValue(), zero when this.doubleValue() equals
+	 *         object.doubleValue(), and less than zero when this.doubleValue()
+	 *         is less than object.doubleValue()
 	 */
 	public int compareTo(Double object) {
-		return value > object.value ? 1 : (value < object.value ? -1 : 0);
+		long d1, d2;
+		long NaNbits = Double.doubleToLongBits(Double.NaN);
+		if ((d1 = Double.doubleToLongBits(value)) == NaNbits) {
+			if (Double.doubleToLongBits(object.value) == NaNbits) {
+				return 0;
+			}
+			return 1;
+		}
+		if ((d2 = Double.doubleToLongBits(object.value)) == NaNbits) {
+			return -1;
+		}
+		if (value == object.value) {
+			if (d1 == d2) {
+				return 0;
+			}
+			// check for -0
+			return d1 > d2 ? 1 : -1;
+		}
+		return value > object.value ? 1 : -1;
 	}
 
 	/**
@@ -103,13 +122,15 @@
 	 * @param object
 	 *            the Double to compare to the receiver
 	 * 
-	 * @return Returns greater than zero when this.doubleValue() >
-	 *         object.doubleValue(), zero when this.doubleValue() ==
-	 *         object.doubleValue(), and less than zero when this.doubleValue() <
-	 *         object.doubleValue()
+	 * @return Returns greater than zero when this.doubleValue() is greater than
+	 *         object.doubleValue(), zero when this.doubleValue() equals
+	 *         object.doubleValue(), and less than zero when this.doubleValue()
+	 *         is less than object.doubleValue()
 	 * 
 	 * @throws ClassCastException
 	 *             when object is not a Double
+	 * 
+	 * @see #compareTo(Double)
 	 */
 	public int compareTo(Object object) {
 		return compareTo((Double) object);
@@ -326,17 +347,37 @@
 	}
 
 	/**
-	 * Compares the two doubles.
+	 * Compares the two doubles. NaN is equal to NaN, and is greater than other
+	 * double values. 0d is greater than -0d.
 	 * 
 	 * @param double1
 	 *            the first value to compare
 	 * @param double2
 	 *            the second value to compare
 	 * 
-	 * @return Returns greater than zero when double1 > double2, zero when
-	 *         double1 == double2, and less than zero when double1 < double2
+	 * @return Returns greater than zero when double1 is greater than double2,
+	 *         zero when double1 equals double2, and less than zero when double1
+	 *         is less than double2
 	 */
 	public static int compare(double double1, double double2) {
-		return double1 > double2 ? 1 : (double1 < double2 ? -1 : 0);
+		long d1, d2;
+		long NaNbits = Double.doubleToLongBits(Double.NaN);
+		if ((d1 = Double.doubleToLongBits(double1)) == NaNbits) {
+			if (Double.doubleToLongBits(double2) == NaNbits) {
+				return 0;
+			}
+			return 1;
+		}
+		if ((d2 = Double.doubleToLongBits(double2)) == NaNbits) {
+			return -1;
+		}
+		if (double1 == double2) {
+			if (d1 == d2) {
+				return 0;
+			}
+			// check for -0
+			return d1 > d2 ? 1 : -1;
+		}
+		return double1 > double2 ? 1 : -1;
 	}
 }

Modified: incubator/harmony/enhanced/classlib/trunk/java-src/luni/src/main/java/java/lang/Float.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/java-src/luni/src/main/java/java/lang/Float.java?rev=360107&r1=360106&r2=360107&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/java-src/luni/src/main/java/java/lang/Float.java
(original)
+++ incubator/harmony/enhanced/classlib/trunk/java-src/luni/src/main/java/java/lang/Float.java
Fri Dec 30 07:35:40 2005
@@ -90,18 +90,37 @@
 	}
 
 	/**
-	 * Compares the receiver with the Float parameter.
+	 * Compares the receiver with the Float parameter. NaN is equal to NaN, and
+	 * is greater than other float values. 0f is greater than -0f.
 	 * 
 	 * @param object
 	 *            the Float to compare to the receiver
 	 * 
-	 * @return Returns greater than zero when this.floatValue() >
-	 *         object.floatValue(), zero when this.floatValue() ==
-	 *         object.floatValue(), and less than zero when this.floatValue() <
-	 *         object.floatValue()
+	 * @return Returns greater than zero when this.floatValue() is greater than
+	 *         object.floatValue(), zero when this.floatValue() equals
+	 *         object.floatValue(), and less than zero when this.floatValue() is
+	 *         less than object.floatValue()
 	 */
 	public int compareTo(Float object) {
-		return value > object.value ? 1 : (value < object.value ? -1 : 0);
+		int f1, f2;
+		int NaNbits = Float.floatToIntBits(Float.NaN);
+		if ((f1 = Float.floatToIntBits(value)) == NaNbits) {
+			if (Float.floatToIntBits(object.value) == NaNbits) {
+				return 0;
+			}
+			return 1;
+		}
+		if ((f2 = Float.floatToIntBits(object.value)) == NaNbits) {
+			return -1;
+		}
+		if (value == object.value) {
+			if (f1 == f2) {
+				return 0;
+			}
+			// check for -0
+			return f1 > f2 ? 1 : -1;
+		}
+		return value > object.value ? 1 : -1;
 	}
 
 	/**
@@ -110,13 +129,15 @@
 	 * @param object
 	 *            the Float to compare to the receiver
 	 * 
-	 * @return Returns greater than zero when this.floatValue() >
-	 *         object.floatValue(), zero when this.floatValue() ==
-	 *         object.floatValue(), and less than zero when this.floatValue() <
-	 *         object.floatValue()
+	 * @return Returns greater than zero when this.floatValue() is greater than
+	 *         object.floatValue(), zero when this.floatValue() equals
+	 *         object.floatValue(), and less than zero when this.floatValue() is
+	 *         less than object.floatValue()
 	 * 
 	 * @throws ClassCastException
 	 *             when object is not a Float
+	 * 
+	 * @see #compareTo(Float)
 	 */
 	public int compareTo(Object object) {
 		return compareTo((Float) object);
@@ -331,17 +352,37 @@
 	}
 
 	/**
-	 * Compares the two floats.
+	 * Compares the two floats. NaN is equal to NaN, and is greater than other
+	 * float values. 0f is greater than -0f.
 	 * 
 	 * @param float1
 	 *            the first value to compare
 	 * @param float2
 	 *            the second value to compare
 	 * 
-	 * @return Returns greater than zero when float1 > float2, zero when float1 ==
-	 *         float2, and less than zero when float1 < float2
+	 * @return Returns greater than zero when float1 is greater than float2,
+	 *         zero when float1 equals float2, and less than zero when float1 is
+	 *         less than float2
 	 */
 	public static int compare(float float1, float float2) {
-		return float1 > float2 ? 1 : (float1 < float2 ? -1 : 0);
+		int f1, f2;
+		int NaNbits = Float.floatToIntBits(Float.NaN);
+		if ((f1 = Float.floatToIntBits(float1)) == NaNbits) {
+			if (Float.floatToIntBits(float2) == NaNbits) {
+				return 0;
+			}
+			return 1;
+		}
+		if ((f2 = Float.floatToIntBits(float2)) == NaNbits) {
+			return -1;
+		}
+		if (float1 == float2) {
+			if (f1 == f2) {
+				return 0;
+			}
+			// check for -0
+			return f1 > f2 ? 1 : -1;
+		}
+		return float1 > float2 ? 1 : -1;
 	}
 }

Modified: incubator/harmony/enhanced/classlib/trunk/java-src/luni/src/main/java/java/util/Arrays.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/java-src/luni/src/main/java/java/util/Arrays.java?rev=360107&r1=360106&r2=360107&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/java-src/luni/src/main/java/java/util/Arrays.java
(original)
+++ incubator/harmony/enhanced/classlib/trunk/java-src/luni/src/main/java/java/util/Arrays.java
Fri Dec 30 07:35:40 2005
@@ -202,19 +202,20 @@
 	 *         is the -index - 1 where the element would be inserted
 	 */
 	public static int binarySearch(double[] array, double value) {
+		long longBits = Double.doubleToLongBits(value);
 		int low = 0, mid = -1, high = array.length - 1;
 		while (low <= high) {
 			mid = (low + high) >> 1;
-			if (value > array[mid])
+			if (lessThan(array[mid], value))
 				low = mid + 1;
-			else if (value == array[mid])
+			else if (longBits == Double.doubleToLongBits(array[mid]))
 				return mid;
 			else
 				high = mid - 1;
 		}
 		if (mid < 0)
 			return -1;
-		return -mid - (value < array[mid] ? 1 : 2);
+		return -mid - (lessThan(value, array[mid]) ? 1 : 2);
 	}
 
 	/**
@@ -229,19 +230,20 @@
 	 *         is the -index - 1 where the element would be inserted
 	 */
 	public static int binarySearch(float[] array, float value) {
+		int intBits = Float.floatToIntBits(value);
 		int low = 0, mid = -1, high = array.length - 1;
 		while (low <= high) {
 			mid = (low + high) >> 1;
-			if (value > array[mid])
+			if (lessThan(array[mid], value))
 				low = mid + 1;
-			else if (value == array[mid])
+			else if (intBits == Float.floatToIntBits(array[mid]))
 				return mid;
 			else
 				high = mid - 1;
 		}
 		if (mid < 0)
 			return -1;
-		return -mid - (value < array[mid] ? 1 : 2);
+		return -mid - (lessThan(value, array[mid]) ? 1 : 2);
 	}
 
 	/**
@@ -876,7 +878,8 @@
 	}
 
 	/**
-	 * Compares the two arrays.
+	 * Compares the two arrays. The values are compared in the same manner as
+	 * Float.equals().
 	 * 
 	 * @param array1
 	 *            the first float array
@@ -884,6 +887,8 @@
 	 *            the second float array
 	 * @return true when the arrays have the same length and the elements at
 	 *         each index in the two arrays are equal, false otherwise
+	 * 
+	 * @see Float#equals(Object)
 	 */
 	public static boolean equals(float[] array1, float[] array2) {
 		if (array1 == array2)
@@ -891,14 +896,17 @@
 		if (array1 == null || array2 == null || array1.length != array2.length)
 			return false;
 		for (int i = 0; i < array1.length; i++) {
-			if (array1[i] != array2[i])
+			if (Float.floatToIntBits(array1[i]) !=
+					Float.floatToIntBits(array2[i])) {
 				return false;
+			}
 		}
 		return true;
 	}
 
 	/**
-	 * Compares the two arrays.
+	 * Compares the two arrays. The values are compared in the same manner as
+	 * Double.equals().
 	 * 
 	 * @param array1
 	 *            the first double array
@@ -906,6 +914,8 @@
 	 *            the second double array
 	 * @return true when the arrays have the same length and the elements at
 	 *         each index in the two arrays are equal, false otherwise
+	 * 
+	 * @see Double#equals(Object)
 	 */
 	public static boolean equals(double[] array1, double[] array2) {
 		if (array1 == array2)
@@ -913,8 +923,10 @@
 		if (array1 == null || array2 == null || array1.length != array2.length)
 			return false;
 		for (int i = 0; i < array1.length; i++) {
-			if (array1[i] != array2[i])
+			if (Double.doubleToLongBits(array1[i]) !=
+					Double.doubleToLongBits(array2[i])) {
 				return false;
+			}
 		}
 		return true;
 	}
@@ -964,6 +976,44 @@
 		return true;
 	}
 
+	private static boolean lessThan(double double1, double double2) {
+		long d1, d2;
+		long NaNbits = Double.doubleToLongBits(Double.NaN);
+		if ((d1 = Double.doubleToLongBits(double1)) == NaNbits) {
+			return false;
+		}
+		if ((d2 = Double.doubleToLongBits(double2)) == NaNbits) {
+			return true;
+		}
+		if (double1 == double2) {
+			if (d1 == d2) {
+				return false;
+			}
+			// check for -0
+			return d1 < d2;
+		}
+		return double1 < double2;
+	}
+
+	private static boolean lessThan(float float1, float float2) {
+		int f1, f2;
+		int NaNbits = Float.floatToIntBits(Float.NaN);
+		if ((f1 = Float.floatToIntBits(float1)) == NaNbits) {
+			return false;
+		}
+		if ((f2 = Float.floatToIntBits(float2)) == NaNbits) {
+			return true;
+		}
+		if (float1 == float2) {
+			if (f1 == f2) {
+				return false;
+			}
+			// check for -0
+			return f1 < f2;
+		}
+		return float1 < float2;
+	}
+
 	private static int med3(byte[] array, int a, int b, int c) {
 		byte x = array[a], y = array[b], z = array[c];
 		return x < y ? (y < z ? b : (x < z ? c : a)) : (y > z ? b : (x > z ? c
@@ -978,14 +1028,16 @@
 
 	private static int med3(double[] array, int a, int b, int c) {
 		double x = array[a], y = array[b], z = array[c];
-		return x < y ? (y < z ? b : (x < z ? c : a)) : (y > z ? b : (x > z ? c
-				: a));
+		return lessThan(x, y)
+			? (lessThan(y, z) ? b : (lessThan(x, z) ? c : a))
+			: (lessThan(z, y) ? b : (lessThan(z, x) ? c : a));
 	}
 
 	private static int med3(float[] array, int a, int b, int c) {
 		float x = array[a], y = array[b], z = array[c];
-		return x < y ? (y < z ? b : (x < z ? c : a)) : (y > z ? b : (x > z ? c
-				: a));
+		return lessThan(x, y)
+			? (lessThan(y, z) ? b : (lessThan(x, z) ? c : a))
+			: (lessThan(z, y) ? b : (lessThan(z, x) ? c : a));
 	}
 
 	private static int med3(int[] array, int a, int b, int c) {
@@ -1231,13 +1283,16 @@
 	 * 
 	 * @param array
 	 *            the double array to be sorted
+	 * 
+	 * @see #sort(double[], int, int)
 	 */
 	public static void sort(double[] array) {
 		sort(0, array.length, array);
 	}
 
 	/**
-	 * Sorts the specified range in the array in ascending order.
+	 * Sorts the specified range in the array in ascending order. The values are
+	 * sorted according to the order imposed by Double.compareTo().
 	 * 
 	 * @param array
 	 *            the double array to be sorted
@@ -1251,6 +1306,8 @@
 	 * @exception ArrayIndexOutOfBoundsException
 	 *                when <code>start < 0</code> or
 	 *                <code>end > array.size()</code>
+	 * 
+	 * @see Double#compareTo(Double)
 	 */
 	public static void sort(double[] array, int start, int end) {
 		if (start >= 0 && end <= array.length) {
@@ -1267,7 +1324,7 @@
 		int length = end - start;
 		if (length < 7) {
 			for (int i = start + 1; i < end; i++)
-				for (int j = i; j > start && array[j - 1] > array[j]; j--) {
+				for (int j = i; j > start && lessThan(array[j], array[j - 1]); j--) {
 					temp = array[j];
 					array[j] = array[j - 1];
 					array[j - 1] = temp;
@@ -1292,7 +1349,7 @@
 		a = b = start;
 		c = d = end - 1;
 		while (true) {
-			while (b <= c && array[b] <= partionValue) {
+			while (b <= c && !lessThan(partionValue, array[b])) {
 				if (array[b] == partionValue) {
 					temp = array[a];
 					array[a++] = array[b];
@@ -1300,7 +1357,7 @@
 				}
 				b++;
 			}
-			while (c >= b && array[c] >= partionValue) {
+			while (c >= b && !lessThan(array[c], partionValue)) {
 				if (array[c] == partionValue) {
 					temp = array[c];
 					array[c] = array[d];
@@ -1341,13 +1398,16 @@
 	 * 
 	 * @param array
 	 *            the float array to be sorted
+	 * 
+	 * @see #sort(float[], int, int)
 	 */
 	public static void sort(float[] array) {
 		sort(0, array.length, array);
 	}
 
 	/**
-	 * Sorts the specified range in the array in ascending order.
+	 * Sorts the specified range in the array in ascending order. The values are
+	 * sorted according to the order imposed by Float.compareTo().
 	 * 
 	 * @param array
 	 *            the float array to be sorted
@@ -1361,6 +1421,8 @@
 	 * @exception ArrayIndexOutOfBoundsException
 	 *                when <code>start < 0</code> or
 	 *                <code>end > array.size()</code>
+	 * 
+	 * @see Float#compareTo(Float)
 	 */
 	public static void sort(float[] array, int start, int end) {
 		if (start >= 0 && end <= array.length) {
@@ -1377,7 +1439,7 @@
 		int length = end - start;
 		if (length < 7) {
 			for (int i = start + 1; i < end; i++)
-				for (int j = i; j > start && array[j - 1] > array[j]; j--) {
+				for (int j = i; j > start && lessThan(array[j], array[j - 1]); j--) {
 					temp = array[j];
 					array[j] = array[j - 1];
 					array[j - 1] = temp;
@@ -1402,7 +1464,7 @@
 		a = b = start;
 		c = d = end - 1;
 		while (true) {
-			while (b <= c && array[b] <= partionValue) {
+			while (b <= c && !lessThan(partionValue, array[b])) {
 				if (array[b] == partionValue) {
 					temp = array[a];
 					array[a++] = array[b];
@@ -1410,7 +1472,7 @@
 				}
 				b++;
 			}
-			while (c >= b && array[c] >= partionValue) {
+			while (c >= b && !lessThan(array[c], partionValue)) {
 				if (array[c] == partionValue) {
 					temp = array[c];
 					array[c] = array[d];

Added: incubator/harmony/enhanced/classlib/trunk/java-src/luni/src/test/java/org/apache/harmony/tests/java/util/ArraysTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/java-src/luni/src/test/java/org/apache/harmony/tests/java/util/ArraysTest.java?rev=360107&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/java-src/luni/src/test/java/org/apache/harmony/tests/java/util/ArraysTest.java
(added)
+++ incubator/harmony/enhanced/classlib/trunk/java-src/luni/src/test/java/org/apache/harmony/tests/java/util/ArraysTest.java
Fri Dec 30 07:35:40 2005
@@ -0,0 +1,162 @@
+package org.apache.harmony.tests.java.util;
+
+import java.util.Arrays;
+
+import junit.framework.TestCase;
+
+public class ArraysTest extends TestCase {
+
+	/**
+	 * @tests java.util.Arrays#binarySearch(double[], double)
+	 */
+	public void test_binarySearch$DD() {
+		double[] specials = new double[] { Double.NEGATIVE_INFINITY,
+				-Double.MAX_VALUE, -2d, -Double.MIN_VALUE, -0d, 0d,
+				Double.MIN_VALUE, 2d, Double.MAX_VALUE,
+				Double.POSITIVE_INFINITY, Double.NaN };
+
+		for (int i = 0; i < specials.length; i++) {
+			int result = Arrays.binarySearch(specials, specials[i]);
+			assertTrue("Assert 0: " + specials[i] + " invalid: " + result,
+					result == i);
+		}
+		assertTrue("Assert 1: Invalid search index for -1d",
+				Arrays.binarySearch(specials, -1d) == -4);
+		assertTrue("Assert 2: Invalid search index for 1d",
+				Arrays.binarySearch(specials, 1d) == -8);
+	}
+	
+	/**
+	 * @tests java.util.Arrays#binarySearch(float[], float)
+	 */
+	public void test_binarySearch$FF() {
+		float[] specials = new float[] { Float.NEGATIVE_INFINITY,
+				-Float.MAX_VALUE, -2f, -Float.MIN_VALUE, -0f, 0f,
+				Float.MIN_VALUE, 2f, Float.MAX_VALUE, Float.POSITIVE_INFINITY,
+				Float.NaN };
+
+		for (int i = 0; i < specials.length; i++) {
+			int result = Arrays.binarySearch(specials, specials[i]);
+			assertTrue("Assert 0: " + specials[i] + " invalid: " + result,
+					result == i);
+		}
+		assertTrue("Assert 1: Invalid search index for -1f",
+				Arrays.binarySearch(specials, -1f) == -4);
+		assertTrue("Assert 2: Invalid search index for 1f",
+				Arrays.binarySearch(specials, 1f) == -8);
+	}
+	
+	/**
+	 * @tests java.util.Arrays#equals(double[], double[])
+	 */
+	public void test_equals$D$D() {
+		double d[] = new double[100];
+		double x[] = new double[100];
+		Arrays.fill(d, Double.MAX_VALUE);
+		Arrays.fill(x, Double.MIN_VALUE);
+
+		assertTrue("Assert 0: Inequal arrays returned true", !Arrays.equals(d, x));
+
+		Arrays.fill(x, Double.MAX_VALUE);
+		assertTrue("Assert 1: equal arrays returned false", Arrays.equals(d, x));
+
+		assertTrue("Assert 2: should be false",
+				!Arrays.equals(new double[] { 1.0 }, new double[] { 2.0 }));
+
+		assertTrue("Assert 3: NaN not equals",
+				Arrays.equals(new double[] { Double.NaN }, new double[] { Double.NaN }));
+		assertTrue("Assert 4: 0d equals -0d",
+				!Arrays.equals(new double[] { 0d }, new double[] { -0d }));
+	}
+	
+	/**
+	 * @tests java.util.Arrays#equals(float[], float[])
+	 */
+	public void test_equals$F$F() {
+		float d[] = new float[100];
+		float x[] = new float[100];
+		Arrays.fill(d, Float.MAX_VALUE);
+		Arrays.fill(x, Float.MIN_VALUE);
+
+		assertTrue("Assert 0: Inequal arrays returned true", !Arrays.equals(d, x));
+
+		Arrays.fill(x, Float.MAX_VALUE);
+		assertTrue("Assert 1: equal arrays returned false", Arrays.equals(d, x));
+
+		assertTrue("Assert 2: NaN not equals",
+				Arrays.equals(new float[] { Float.NaN }, new float[] { Float.NaN }));
+		assertTrue("Assert 3: 0f equals -0f",
+				!Arrays.equals(new float[] { 0f }, new float[] { -0f }));
+	}
+	
+	/**
+	 * @tests java.util.Arrays#sort(double[])
+	 */
+	public void test_sort$D() {
+		// Test a basic sort
+		double[] reversedArray = new double[100];
+		for (int counter = 0; counter < reversedArray.length; counter ++)
+			reversedArray[counter] = (double)(reversedArray.length - counter - 1);
+		Arrays.sort(reversedArray);
+		for (int counter = 0; counter < reversedArray.length; counter ++) {
+			assertTrue("Assert 0: Resulting array not sorted",
+					reversedArray[counter] == (double)counter);
+		}
+
+		// These have to sort as per the Double compare ordering
+		double[] specials1 = new double[]{Double.NaN, Double.MAX_VALUE, Double.MIN_VALUE, 0d, -0d,
Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY};
+		double[] specials2 = new double[]{0d, Double.POSITIVE_INFINITY, -0d, Double.NEGATIVE_INFINITY,
Double.MIN_VALUE, Double.NaN, Double.MAX_VALUE};
+		double[] answer = new double[]{Double.NEGATIVE_INFINITY, -0d, 0d, Double.MIN_VALUE, Double.MAX_VALUE,
Double.POSITIVE_INFINITY, Double.NaN};
+
+		Arrays.sort(specials1);
+		Object[] print1 = new Object[specials1.length];
+		for (int i = 0; i < specials1.length; i++) {
+			print1[i] = new Double(specials1[i]);
+		}
+		assertTrue("Assert 1: specials sort incorrectly" + Arrays.asList(print1),
+				Arrays.equals(specials1, answer));
+
+		Arrays.sort(specials2);
+		Object[] print2 = new Object[specials2.length];
+		for (int i = 0; i < specials2.length; i++)
+			print2[i] = new Double(specials2[i]);
+		assertTrue("Assert 2: specials sort incorrectly " + Arrays.asList(print2), 
+				Arrays.equals(specials2, answer));
+	}
+	
+	/**
+	 * @tests java.util.Arrays#sort(float[])
+	 */
+	public void test_sort$F() {
+		// Test a basic sort
+		float[] reversedArray = new float[100];
+		for (int counter = 0; counter < reversedArray.length; counter ++) {
+			reversedArray[counter] = (float)(reversedArray.length - counter - 1);
+		}
+		Arrays.sort(reversedArray);
+		for (int counter = 0; counter < reversedArray.length; counter ++) {
+			assertTrue("Assert 0: Resulting array not sorted",
+					reversedArray[counter] == (float)counter);
+		}
+
+		float[] specials1 = new float[]{Float.NaN, Float.MAX_VALUE, Float.MIN_VALUE, 0f, -0f, Float.POSITIVE_INFINITY,
Float.NEGATIVE_INFINITY};
+		float[] specials2 = new float[]{0f, Float.POSITIVE_INFINITY, -0f, Float.NEGATIVE_INFINITY,
Float.MIN_VALUE, Float.NaN, Float.MAX_VALUE};
+		float[] answer = new float[]{Float.NEGATIVE_INFINITY, -0f, 0f, Float.MIN_VALUE, Float.MAX_VALUE,
Float.POSITIVE_INFINITY, Float.NaN};
+
+		Arrays.sort(specials1);
+		Object[] print1 = new Object[specials1.length];
+		for (int i = 0; i < specials1.length; i++) {
+			print1[i] = new Float(specials1[i]);
+		}
+		assertTrue("Assert 1: specials sort incorrectly" + Arrays.asList(print1),
+				Arrays.equals(specials1, answer));
+
+		Arrays.sort(specials2);
+		Object[] print2 = new Object[specials2.length];
+		for (int i = 0; i < specials2.length; i++) {
+			print2[i] = new Float(specials2[i]);
+		}
+		assertTrue("Assert 2: specials sort incorrectly" + Arrays.asList(print2), 
+				Arrays.equals(specials2, answer));
+	}
+}



Mime
View raw message