scolebourne 2003/06/28 11:01:19
Modified: lang/src/java/org/apache/commons/lang ArrayUtils.java
lang/src/test/org/apache/commons/lang ArrayUtilsTest.java
Log:
Add primitive/object conversions for all types
bug 21068, from Matthew Hawthorne
Revision Changes Path
1.16 +413 -2
jakarta-commons/lang/src/java/org/apache/commons/lang/ArrayUtils.java
Index: ArrayUtils.java
===================================================================
RCS file:
/home/cvs/jakarta-commons/lang/src/java/org/apache/commons/lang/ArrayUtils.java,v
retrieving revision 1.15
retrieving revision 1.16
diff -u -r1.15 -r1.16
--- ArrayUtils.java 25 Jun 2003 23:33:47 -0000 1.15
+++ ArrayUtils.java 28 Jun 2003 18:01:18 -0000 1.16
@@ -906,7 +906,10 @@
return (indexOf(array, objectToFind) != -1);
}
- // Primitive/Object converters
+ // Primitive/Object array converters
+ // ----------------------------------------------------------------------
+
+ // Boolean array converters
// ----------------------------------------------------------------------
/**
* <p>Converts an array of object Booleans to primitives.</p>
@@ -970,6 +973,414 @@
final Boolean[] result = new Boolean[array.length];
for (int i = 0; i < array.length; i++) {
result[i] = (array[i] ? Boolean.TRUE : Boolean.FALSE);
+ }
+ return result;
+ }
+
+ // Byte array converters
+ // ----------------------------------------------------------------------
+ /**
+ * <p>Converts an array of object Bytes to primitives.</p>
+ *
+ * <p>This method returns <code>null</code> if <code>null</code> input.</p>
+ *
+ * @param array a <code>Byte</code> array, may be <code>null</code>
+ * @return a <code>byte</code> array
+ * @throws NullPointerException if array content is <code>null</code>
+ */
+ public static byte[] toPrimitive(final Byte[] array) {
+ if (array == null) {
+ return null;
+ } else if (array.length == 0) {
+ return EMPTY_BYTE_ARRAY;
+ }
+ final byte[] result = new byte[array.length];
+ for (int i = 0; i < array.length; i++) {
+ result[i] = array[i].byteValue();
+ }
+ return result;
+ }
+
+ /**
+ * <p>Converts an array of object Bytes to primitives handling null.</p>
+ *
+ * <p>This method returns <code>null</code> if <code>null</code> input.</p>
+ *
+ * @param array a <code>Byte</code> array, may be <code>null</code>
+ * @param valueForNull the value to insert if <code>null</code> found
+ * @return a <code>byte</code> array
+ */
+ public static byte[] toPrimitive(final Byte[] array, final byte valueForNull) {
+ if (array == null) {
+ return null;
+ } else if (array.length == 0) {
+ return EMPTY_BYTE_ARRAY;
+ }
+ final byte[] result = new byte[array.length];
+ for (int i = 0; i < array.length; i++) {
+ Byte b = array[i];
+ result[i] = (b == null ? valueForNull : b.byteValue());
+ }
+ return result;
+ }
+
+ /**
+ * <p>Converts an array of primitive bytes to objects.</p>
+ *
+ * <p>This method returns <code>null</code> if <code>null</code> input.</p>
+ *
+ * @param array a <code>byte</code> array
+ * @return a <code>Byte</code> array
+ */
+ public static Byte[] toObject(final byte[] array) {
+ if (array == null) {
+ return null;
+ } else if (array.length == 0) {
+ return EMPTY_BYTE_OBJECT_ARRAY;
+ }
+ final Byte[] result = new Byte[array.length];
+ for (int i = 0; i < array.length; i++) {
+ result[i] = new Byte(array[i]);
+ }
+ return result;
+ }
+
+ // Short array converters
+ // ----------------------------------------------------------------------
+ /**
+ * <p>Converts an array of object Shorts to primitives.</p>
+ *
+ * <p>This method returns <code>null</code> if <code>null</code> input.</p>
+ *
+ * @param array a <code>Short</code> array, may be <code>null</code>
+ * @return a <code>byte</code> array
+ * @throws NullPointerException if array content is <code>null</code>
+ */
+ public static short[] toPrimitive(final Short[] array) {
+ if (array == null) {
+ return null;
+ } else if (array.length == 0) {
+ return EMPTY_SHORT_ARRAY;
+ }
+ final short[] result = new short[array.length];
+ for (int i = 0; i < array.length; i++) {
+ result[i] = array[i].shortValue();
+ }
+ return result;
+ }
+
+ /**
+ * <p>Converts an array of object Short to primitives handling null.</p>
+ *
+ * <p>This method returns <code>null</code> if <code>null</code> input.</p>
+ *
+ * @param array a <code>Short</code> array, may be <code>null</code>
+ * @param valueForNull the value to insert if <code>null</code> found
+ * @return a <code>byte</code> array
+ */
+ public static short[] toPrimitive(final Short[] array, final short
valueForNull) {
+ if (array == null) {
+ return null;
+ } else if (array.length == 0) {
+ return EMPTY_SHORT_ARRAY;
+ }
+ final short[] result = new short[array.length];
+ for (int i = 0; i < array.length; i++) {
+ Short b = array[i];
+ result[i] = (b == null ? valueForNull : b.shortValue());
+ }
+ return result;
+ }
+
+ /**
+ * <p>Converts an array of primitive shorts to objects.</p>
+ *
+ * <p>This method returns <code>null</code> if <code>null</code> input.</p>
+ *
+ * @param array a <code>short</code> array
+ * @return a <code>Short</code> array
+ */
+ public static Short[] toObject(final short[] array) {
+ if (array == null) {
+ return null;
+ } else if (array.length == 0) {
+ return EMPTY_SHORT_OBJECT_ARRAY;
+ }
+ final Short[] result = new Short[array.length];
+ for (int i = 0; i < array.length; i++) {
+ result[i] = new Short(array[i]);
+ }
+ return result;
+ }
+
+ // Int array converters
+ // ----------------------------------------------------------------------
+ /**
+ * <p>Converts an array of object Integers to primitives.</p>
+ *
+ * <p>This method returns <code>null</code> if <code>null</code> input.</p>
+ *
+ * @param array a <code>Integer</code> array, may be <code>null</code>
+ * @return an <code>int</code> array
+ * @throws NullPointerException if array content is <code>null</code>
+ */
+ public static int[] toPrimitive(final Integer[] array) {
+ if (array == null) {
+ return null;
+ } else if (array.length == 0) {
+ return EMPTY_INT_ARRAY;
+ }
+ final int[] result = new int[array.length];
+ for (int i = 0; i < array.length; i++) {
+ result[i] = array[i].intValue();
+ }
+ return result;
+ }
+
+ /**
+ * <p>Converts an array of object Integer to primitives handling null.</p>
+ *
+ * <p>This method returns <code>null</code> if <code>null</code> input.</p>
+ *
+ * @param array a <code>Integer</code> array, may be <code>null</code>
+ * @param valueForNull the value to insert if <code>null</code> found
+ * @return an <code>int</code> array
+ */
+ public static int[] toPrimitive(final Integer[] array, final int valueForNull) {
+ if (array == null) {
+ return null;
+ } else if (array.length == 0) {
+ return EMPTY_INT_ARRAY;
+ }
+ final int[] result = new int[array.length];
+ for (int i = 0; i < array.length; i++) {
+ Integer b = array[i];
+ result[i] = (b == null ? valueForNull : b.intValue());
+ }
+ return result;
+ }
+
+ /**
+ * <p>Converts an array of primitive ints to objects.</p>
+ *
+ * <p>This method returns <code>null</code> if <code>null</code> input.</p>
+ *
+ * @param array an <code>int</code> array
+ * @return an <code>Integer</code> array
+ */
+ public static Integer[] toObject(final int[] array) {
+ if (array == null) {
+ return null;
+ } else if (array.length == 0) {
+ return EMPTY_INTEGER_OBJECT_ARRAY;
+ }
+ final Integer[] result = new Integer[array.length];
+ for (int i = 0; i < array.length; i++) {
+ result[i] = new Integer(array[i]);
+ }
+ return result;
+ }
+
+ // Long array converters
+ // ----------------------------------------------------------------------
+ /**
+ * <p>Converts an array of object Longs to primitives.</p>
+ *
+ * <p>This method returns <code>null</code> if <code>null</code> input.</p>
+ *
+ * @param array a <code>Long</code> array, may be <code>null</code>
+ * @return a <code>long</code> array
+ * @throws NullPointerException if array content is <code>null</code>
+ */
+ public static long[] toPrimitive(final Long[] array) {
+ if (array == null) {
+ return null;
+ } else if (array.length == 0) {
+ return EMPTY_LONG_ARRAY;
+ }
+ final long[] result = new long[array.length];
+ for (int i = 0; i < array.length; i++) {
+ result[i] = array[i].longValue();
+ }
+ return result;
+ }
+
+ /**
+ * <p>Converts an array of object Long to primitives handling null.</p>
+ *
+ * <p>This method returns <code>null</code> if <code>null</code> input.</p>
+ *
+ * @param array a <code>Long</code> array, may be <code>null</code>
+ * @param valueForNull the value to insert if <code>null</code> found
+ * @return a <code>long</code> array
+ */
+ public static long[] toPrimitive(final Long[] array, final long valueForNull) {
+ if (array == null) {
+ return null;
+ } else if (array.length == 0) {
+ return EMPTY_LONG_ARRAY;
+ }
+ final long[] result = new long[array.length];
+ for (int i = 0; i < array.length; i++) {
+ Long b = array[i];
+ result[i] = (b == null ? valueForNull : b.longValue());
+ }
+ return result;
+ }
+
+ /**
+ * <p>Converts an array of primitive longs to objects.</p>
+ *
+ * <p>This method returns <code>null</code> if <code>null</code> input.</p>
+ *
+ * @param array a <code>long</code> array
+ * @return a <code>Long</code> array
+ */
+ public static Long[] toObject(final long[] array) {
+ if (array == null) {
+ return null;
+ } else if (array.length == 0) {
+ return EMPTY_LONG_OBJECT_ARRAY;
+ }
+ final Long[] result = new Long[array.length];
+ for (int i = 0; i < array.length; i++) {
+ result[i] = new Long(array[i]);
+ }
+ return result;
+ }
+
+ // Float array converters
+ // ----------------------------------------------------------------------
+ /**
+ * <p>Converts an array of object Floats to primitives.</p>
+ *
+ * <p>This method returns <code>null</code> if <code>null</code> input.</p>
+ *
+ * @param array a <code>Float</code> array, may be <code>null</code>
+ * @return a <code>float</code> array
+ * @throws NullPointerException if array content is <code>null</code>
+ */
+ public static float[] toPrimitive(final Float[] array) {
+ if (array == null) {
+ return null;
+ } else if (array.length == 0) {
+ return EMPTY_FLOAT_ARRAY;
+ }
+ final float[] result = new float[array.length];
+ for (int i = 0; i < array.length; i++) {
+ result[i] = array[i].floatValue();
+ }
+ return result;
+ }
+
+ /**
+ * <p>Converts an array of object Floats to primitives handling null.</p>
+ *
+ * <p>This method returns <code>null</code> if <code>null</code> input.</p>
+ *
+ * @param array a <code>Float</code> array, may be <code>null</code>
+ * @param valueForNull the value to insert if <code>null</code> found
+ * @return a <code>float</code> array
+ */
+ public static float[] toPrimitive(final Float[] array, final float
valueForNull) {
+ if (array == null) {
+ return null;
+ } else if (array.length == 0) {
+ return EMPTY_FLOAT_ARRAY;
+ }
+ final float[] result = new float[array.length];
+ for (int i = 0; i < array.length; i++) {
+ Float b = array[i];
+ result[i] = (b == null ? valueForNull : b.floatValue());
+ }
+ return result;
+ }
+
+ /**
+ * <p>Converts an array of primitive floats to objects.</p>
+ *
+ * <p>This method returns <code>null</code> if <code>null</code> input.</p>
+ *
+ * @param array a <code>float</code> array
+ * @return a <code>Float</code> array
+ */
+ public static Float[] toObject(final float[] array) {
+ if (array == null) {
+ return null;
+ } else if (array.length == 0) {
+ return EMPTY_FLOAT_OBJECT_ARRAY;
+ }
+ final Float[] result = new Float[array.length];
+ for (int i = 0; i < array.length; i++) {
+ result[i] = new Float(array[i]);
+ }
+ return result;
+ }
+
+ // Double array converters
+ // ----------------------------------------------------------------------
+ /**
+ * <p>Converts an array of object Doubles to primitives.</p>
+ *
+ * <p>This method returns <code>null</code> if <code>null</code> input.</p>
+ *
+ * @param array a <code>Double</code> array, may be <code>null</code>
+ * @return a <code>double</code> array
+ * @throws NullPointerException if array content is <code>null</code>
+ */
+ public static double[] toPrimitive(final Double[] array) {
+ if (array == null) {
+ return null;
+ } else if (array.length == 0) {
+ return EMPTY_DOUBLE_ARRAY;
+ }
+ final double[] result = new double[array.length];
+ for (int i = 0; i < array.length; i++) {
+ result[i] = array[i].doubleValue();
+ }
+ return result;
+ }
+
+ /**
+ * <p>Converts an array of object Doubles to primitives handling null.</p>
+ *
+ * <p>This method returns <code>null</code> if <code>null</code> input.</p>
+ *
+ * @param array a <code>Double</code> array, may be <code>null</code>
+ * @param valueForNull the value to insert if <code>null</code> found
+ * @return a <code>double</code> array
+ */
+ public static double[] toPrimitive(final Double[] array, final double
valueForNull) {
+ if (array == null) {
+ return null;
+ } else if (array.length == 0) {
+ return EMPTY_DOUBLE_ARRAY;
+ }
+ final double[] result = new double[array.length];
+ for (int i = 0; i < array.length; i++) {
+ Double b = array[i];
+ result[i] = (b == null ? valueForNull : b.doubleValue());
+ }
+ return result;
+ }
+
+ /**
+ * <p>Converts an array of primitive doubles to objects.</p>
+ *
+ * <p>This method returns <code>null</code> if <code>null</code> input.</p>
+ *
+ * @param array a <code>double</code> array
+ * @return a <code>Double</code> array
+ */
+ public static Double[] toObject(final double[] array) {
+ if (array == null) {
+ return null;
+ } else if (array.length == 0) {
+ return EMPTY_DOUBLE_OBJECT_ARRAY;
+ }
+ final Double[] result = new Double[array.length];
+ for (int i = 0; i < array.length; i++) {
+ result[i] = new Double(array[i]);
}
return result;
}
1.8 +343 -7
jakarta-commons/lang/src/test/org/apache/commons/lang/ArrayUtilsTest.java
Index: ArrayUtilsTest.java
===================================================================
RCS file:
/home/cvs/jakarta-commons/lang/src/test/org/apache/commons/lang/ArrayUtilsTest.java,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -r1.7 -r1.8
--- ArrayUtilsTest.java 25 Jun 2003 23:33:47 -0000 1.7
+++ ArrayUtilsTest.java 28 Jun 2003 18:01:19 -0000 1.8
@@ -142,10 +142,7 @@
assertEquals("bar", map.get("foo"));
assertEquals("world", map.get("hello"));
- try {
- ArrayUtils.toMap(null);
- fail("exception expected");
- } catch (IllegalArgumentException ex) {}
+ assertEquals(null, ArrayUtils.toMap(null));
try {
ArrayUtils.toMap(new String[][] {{"foo", "bar"}, {"short"}});
fail("exception expected");
@@ -711,7 +708,8 @@
// testToPrimitive/Object for boolean
// -----------------------------------------------------------------------
public void testToPrimitive_boolean() {
- assertEquals(null, ArrayUtils.toPrimitive(null));
+ final Boolean[] b = null;
+ assertEquals(null, ArrayUtils.toPrimitive(b));
assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.toPrimitive(new
Boolean[0]));
assertTrue(Arrays.equals(
new boolean[] {true, false, true},
@@ -742,12 +740,350 @@
}
public void testToObject_boolean() {
- assertEquals(null, ArrayUtils.toObject(null));
+ final boolean[] b = null;
+ assertEquals(null, ArrayUtils.toObject(b));
assertSame(ArrayUtils.EMPTY_BOOLEAN_OBJECT_ARRAY, ArrayUtils.toObject(new
boolean[0]));
assertTrue(Arrays.equals(
new Boolean[] {Boolean.TRUE, Boolean.FALSE, Boolean.TRUE},
ArrayUtils.toObject(new boolean[] {true, false, true}))
);
+ }
+
+ // testToPrimitive/Object for byte
+ // -----------------------------------------------------------------------
+ public void testToPrimitive_byte() {
+ final Byte[] b = null;
+ assertEquals(null, ArrayUtils.toPrimitive(b));
+
+ assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.toPrimitive(new
Byte[0]));
+
+ assertTrue(Arrays.equals(
+ new byte[] {Byte.MIN_VALUE, Byte.MAX_VALUE, (byte)9999999},
+ ArrayUtils.toPrimitive(new Byte[] {new Byte(Byte.MIN_VALUE),
+ new Byte(Byte.MAX_VALUE), new Byte((byte)9999999)}))
+ );
+
+ try {
+ ArrayUtils.toPrimitive(new Byte[] {new Byte(Byte.MIN_VALUE), null});
+ fail();
+ } catch (NullPointerException ex) {}
+ }
+
+ public void testToPrimitive_byte_byte() {
+ final Byte[] b = null;
+ assertEquals(null, ArrayUtils.toPrimitive(b, Byte.MIN_VALUE));
+
+ assertSame(ArrayUtils.EMPTY_BYTE_ARRAY,
+ ArrayUtils.toPrimitive(new Byte[0], (byte)1));
+
+ assertTrue(Arrays.equals(
+ new byte[] {Byte.MIN_VALUE, Byte.MAX_VALUE, (byte)9999999},
+ ArrayUtils.toPrimitive(new Byte[] {new Byte(Byte.MIN_VALUE),
+ new Byte(Byte.MAX_VALUE), new Byte((byte)9999999)},
+ Byte.MIN_VALUE))
+ );
+
+ assertTrue(Arrays.equals(
+ new byte[] {Byte.MIN_VALUE, Byte.MAX_VALUE, (byte)9999999},
+ ArrayUtils.toPrimitive(new Byte[] {new Byte(Byte.MIN_VALUE), null,
+ new Byte((byte)9999999)}, Byte.MAX_VALUE))
+ );
+ }
+
+ public void testToObject_byte() {
+ final byte[] b = null;
+ assertEquals(null, ArrayUtils.toObject(b));
+
+ assertSame(ArrayUtils.EMPTY_BYTE_OBJECT_ARRAY,
+ ArrayUtils.toObject(new byte[0]));
+
+ assertTrue(Arrays.equals(
+ new Byte[] {new Byte(Byte.MIN_VALUE),
+ new Byte(Byte.MAX_VALUE), new Byte((byte)9999999)},
+ ArrayUtils.toObject(new byte[] {Byte.MIN_VALUE, Byte.MAX_VALUE,
+ (byte)9999999}))
+ );
+ }
+
+ // testToPrimitive/Object for short
+ // -----------------------------------------------------------------------
+ public void testToPrimitive_short() {
+ final Short[] b = null;
+ assertEquals(null, ArrayUtils.toPrimitive(b));
+
+ assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.toPrimitive(new
Short[0]));
+
+ assertTrue(Arrays.equals(
+ new short[] {Short.MIN_VALUE, Short.MAX_VALUE, (short)9999999},
+ ArrayUtils.toPrimitive(new Short[] {new Short(Short.MIN_VALUE),
+ new Short(Short.MAX_VALUE), new Short((short)9999999)}))
+ );
+
+ try {
+ ArrayUtils.toPrimitive(new Short[] {new Short(Short.MIN_VALUE), null});
+ fail();
+ } catch (NullPointerException ex) {}
+ }
+
+ public void testToPrimitive_short_short() {
+ final Short[] s = null;
+ assertEquals(null, ArrayUtils.toPrimitive(s, Short.MIN_VALUE));
+
+ assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.toPrimitive(new
Short[0],
+ Short.MIN_VALUE));
+
+ assertTrue(Arrays.equals(
+ new short[] {Short.MIN_VALUE, Short.MAX_VALUE, (short)9999999},
+ ArrayUtils.toPrimitive(new Short[] {new Short(Short.MIN_VALUE),
+ new Short(Short.MAX_VALUE), new Short((short)9999999)},
Short.MIN_VALUE))
+ );
+
+ assertTrue(Arrays.equals(
+ new short[] {Short.MIN_VALUE, Short.MAX_VALUE, (short)9999999},
+ ArrayUtils.toPrimitive(new Short[] {new Short(Short.MIN_VALUE), null,
+ new Short((short)9999999)}, Short.MAX_VALUE))
+ );
+ }
+
+ public void testToObject_short() {
+ final short[] b = null;
+ assertEquals(null, ArrayUtils.toObject(b));
+
+ assertSame(ArrayUtils.EMPTY_SHORT_OBJECT_ARRAY,
+ ArrayUtils.toObject(new short[0]));
+
+ assertTrue(Arrays.equals(
+ new Short[] {new Short(Short.MIN_VALUE), new Short(Short.MAX_VALUE),
+ new Short((short)9999999)},
+ ArrayUtils.toObject(new short[] {Short.MIN_VALUE, Short.MAX_VALUE,
+ (short)9999999}))
+ );
+ }
+
+ // testToPrimitive/Object for int
+ // -----------------------------------------------------------------------
+ public void testToPrimitive_int() {
+ final Integer[] b = null;
+ assertEquals(null, ArrayUtils.toPrimitive(b));
+ assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.toPrimitive(new
Integer[0]));
+ assertTrue(Arrays.equals(
+ new int[] {Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999},
+ ArrayUtils.toPrimitive(new Integer[] {new Integer(Integer.MIN_VALUE),
+ new Integer(Integer.MAX_VALUE), new Integer(9999999)}))
+ );
+
+ try {
+ ArrayUtils.toPrimitive(new Integer[] {new Integer(Integer.MIN_VALUE),
null});
+ fail();
+ } catch (NullPointerException ex) {}
+ }
+
+ public void testToPrimitive_int_int() {
+ final Long[] l = null;
+ assertEquals(null, ArrayUtils.toPrimitive(l, Integer.MIN_VALUE));
+ assertSame(ArrayUtils.EMPTY_INT_ARRAY,
+ ArrayUtils.toPrimitive(new Integer[0], 1));
+ assertTrue(Arrays.equals(
+ new int[] {Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999},
+ ArrayUtils.toPrimitive(new Integer[] {new Integer(Integer.MIN_VALUE),
+ new Integer(Integer.MAX_VALUE), new Integer(9999999)},1)));
+ assertTrue(Arrays.equals(
+ new int[] {Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999},
+ ArrayUtils.toPrimitive(new Integer[] {new Integer(Integer.MIN_VALUE),
+ null, new Integer(9999999)}, Integer.MAX_VALUE))
+ );
+ }
+
+ public void testToObject_int() {
+ final int[] b = null;
+ assertEquals(null, ArrayUtils.toObject(b));
+
+ assertSame(
+ ArrayUtils.EMPTY_INTEGER_OBJECT_ARRAY,
+ ArrayUtils.toObject(new int[0]));
+
+ assertTrue(
+ Arrays.equals(
+ new Integer[] {
+ new Integer(Integer.MIN_VALUE),
+ new Integer(Integer.MAX_VALUE),
+ new Integer(9999999)},
+ ArrayUtils.toObject(
+ new int[] { Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999 })));
+ }
+
+ // testToPrimitive/Object for long
+ // -----------------------------------------------------------------------
+ public void testToPrimitive_long() {
+ final Long[] b = null;
+ assertEquals(null, ArrayUtils.toPrimitive(b));
+
+ assertSame(ArrayUtils.EMPTY_LONG_ARRAY,
+ ArrayUtils.toPrimitive(new Long[0]));
+
+ assertTrue(Arrays.equals(
+ new long[] {Long.MIN_VALUE, Long.MAX_VALUE, 9999999},
+ ArrayUtils.toPrimitive(new Long[] {new Long(Long.MIN_VALUE),
+ new Long(Long.MAX_VALUE), new Long(9999999)}))
+ );
+
+ try {
+ ArrayUtils.toPrimitive(new Long[] {new Long(Long.MIN_VALUE), null});
+ fail();
+ } catch (NullPointerException ex) {}
+ }
+
+ public void testToPrimitive_long_long() {
+ final Long[] l = null;
+ assertEquals(null, ArrayUtils.toPrimitive(l, Long.MIN_VALUE));
+
+ assertSame(ArrayUtils.EMPTY_LONG_ARRAY,
+ ArrayUtils.toPrimitive(new Long[0], 1));
+
+ assertTrue(Arrays.equals(
+ new long[] {Long.MIN_VALUE, Long.MAX_VALUE, 9999999},
+ ArrayUtils.toPrimitive(new Long[] {new Long(Long.MIN_VALUE),
+ new Long(Long.MAX_VALUE), new Long(9999999)},1)));
+
+ assertTrue(Arrays.equals(
+ new long[] {Long.MIN_VALUE, Long.MAX_VALUE, 9999999},
+ ArrayUtils.toPrimitive(new Long[] {new Long(Long.MIN_VALUE),
+ null, new Long(9999999)}, Long.MAX_VALUE))
+ );
+ }
+
+ public void testToObject_long() {
+ final long[] b = null;
+ assertEquals(null, ArrayUtils.toObject(b));
+
+ assertSame(
+ ArrayUtils.EMPTY_LONG_OBJECT_ARRAY,
+ ArrayUtils.toObject(new long[0]));
+
+ assertTrue(
+ Arrays.equals(
+ new Long[] {
+ new Long(Long.MIN_VALUE),
+ new Long(Long.MAX_VALUE),
+ new Long(9999999)},
+ ArrayUtils.toObject(
+ new long[] { Long.MIN_VALUE, Long.MAX_VALUE, 9999999 })));
+ }
+
+ // testToPrimitive/Object for float
+ // -----------------------------------------------------------------------
+ public void testToPrimitive_float() {
+ final Float[] b = null;
+ assertEquals(null, ArrayUtils.toPrimitive(b));
+
+ assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY,
+ ArrayUtils.toPrimitive(new Float[0]));
+
+ assertTrue(Arrays.equals(
+ new float[] {Float.MIN_VALUE, Float.MAX_VALUE, 9999999},
+ ArrayUtils.toPrimitive(new Float[] {new Float(Float.MIN_VALUE),
+ new Float(Float.MAX_VALUE), new Float(9999999)}))
+ );
+
+ try {
+ ArrayUtils.toPrimitive(new Float[] {new Float(Float.MIN_VALUE), null});
+ fail();
+ } catch (NullPointerException ex) {}
+ }
+
+ public void testToPrimitive_float_float() {
+ final Float[] l = null;
+ assertEquals(null, ArrayUtils.toPrimitive(l, Float.MIN_VALUE));
+
+ assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY,
+ ArrayUtils.toPrimitive(new Float[0], 1));
+
+ assertTrue(Arrays.equals(
+ new float[] {Float.MIN_VALUE, Float.MAX_VALUE, 9999999},
+ ArrayUtils.toPrimitive(new Float[] {new Float(Float.MIN_VALUE),
+ new Float(Float.MAX_VALUE), new Float(9999999)},1)));
+
+ assertTrue(Arrays.equals(
+ new float[] {Float.MIN_VALUE, Float.MAX_VALUE, 9999999},
+ ArrayUtils.toPrimitive(new Float[] {new Float(Float.MIN_VALUE),
+ null, new Float(9999999)}, Float.MAX_VALUE))
+ );
+ }
+
+ public void testToObject_float() {
+ final float[] b = null;
+ assertEquals(null, ArrayUtils.toObject(b));
+
+ assertSame(
+ ArrayUtils.EMPTY_FLOAT_OBJECT_ARRAY,
+ ArrayUtils.toObject(new float[0]));
+
+ assertTrue(
+ Arrays.equals(
+ new Float[] {
+ new Float(Float.MIN_VALUE),
+ new Float(Float.MAX_VALUE),
+ new Float(9999999)},
+ ArrayUtils.toObject(
+ new float[] { Float.MIN_VALUE, Float.MAX_VALUE, 9999999 })));
+ }
+
+ // testToPrimitive/Object for double
+ // -----------------------------------------------------------------------
+ public void testToPrimitive_double() {
+ final Double[] b = null;
+ assertEquals(null, ArrayUtils.toPrimitive(b));
+
+ assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY,
+ ArrayUtils.toPrimitive(new Double[0]));
+
+ assertTrue(Arrays.equals(
+ new double[] {Double.MIN_VALUE, Double.MAX_VALUE, 9999999},
+ ArrayUtils.toPrimitive(new Double[] {new Double(Double.MIN_VALUE),
+ new Double(Double.MAX_VALUE), new Double(9999999)}))
+ );
+
+ try {
+ ArrayUtils.toPrimitive(new Float[] {new Float(Float.MIN_VALUE), null});
+ fail();
+ } catch (NullPointerException ex) {}
+ }
+
+ public void testToPrimitive_double_double() {
+ final Double[] l = null;
+ assertEquals(null, ArrayUtils.toPrimitive(l, Double.MIN_VALUE));
+
+ assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY,
+ ArrayUtils.toPrimitive(new Double[0], 1));
+
+ assertTrue(Arrays.equals(
+ new double[] {Double.MIN_VALUE, Double.MAX_VALUE, 9999999},
+ ArrayUtils.toPrimitive(new Double[] {new Double(Double.MIN_VALUE),
+ new Double(Double.MAX_VALUE), new Double(9999999)},1)));
+
+ assertTrue(Arrays.equals(
+ new double[] {Double.MIN_VALUE, Double.MAX_VALUE, 9999999},
+ ArrayUtils.toPrimitive(new Double[] {new Double(Double.MIN_VALUE),
+ null, new Double(9999999)}, Double.MAX_VALUE))
+ );
+ }
+
+ public void testToObject_double() {
+ final double[] b = null;
+ assertEquals(null, ArrayUtils.toObject(b));
+
+ assertSame(
+ ArrayUtils.EMPTY_DOUBLE_OBJECT_ARRAY,
+ ArrayUtils.toObject(new double[0]));
+
+ assertTrue(
+ Arrays.equals(
+ new Double[] {
+ new Double(Double.MIN_VALUE),
+ new Double(Double.MAX_VALUE),
+ new Double(9999999)},
+ ArrayUtils.toObject(
+ new double[] { Double.MIN_VALUE, Double.MAX_VALUE, 9999999 })));
}
}
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
