You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@commons.apache.org by sc...@apache.org on 2002/11/16 13:56:44 UTC
cvs commit: jakarta-commons/lang/src/test/org/apache/commons/lang ArrayUtilsTest.java
scolebourne 2002/11/16 04:56:44
Modified: lang/src/java/org/apache/commons/lang ArrayUtils.java
lang/src/test/org/apache/commons/lang ArrayUtilsTest.java
Log:
Add to ArrayUtils and test it
Revision Changes Path
1.5 +96 -11 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.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- ArrayUtils.java 16 Nov 2002 10:41:03 -0000 1.4
+++ ArrayUtils.java 16 Nov 2002 12:56:43 -0000 1.5
@@ -56,6 +56,8 @@
import java.util.HashMap;
import java.util.Map;
+import org.apache.commons.lang.builder.EqualsBuilder;
+import org.apache.commons.lang.builder.HashCodeBuilder;
import org.apache.commons.lang.builder.ToStringBuilder;
import org.apache.commons.lang.builder.ToStringStyle;
/**
@@ -100,6 +102,7 @@
public ArrayUtils() {
}
+ // Basic methods handling multi-dimensional arrays
//--------------------------------------------------------------------------
/**
@@ -110,7 +113,7 @@
*
* <p>The format is that of Java source code, for example {a,b}.</p>
*
- * @param array the array to get a toString for, may not be <code>null</code>
+ * @param array the array to get a toString for, may be <code>null</code>
* @return a String representation of the array, '{}' if <code>null</code> passed in
*/
public static String toString(Object array) {
@@ -137,6 +140,34 @@
}
/**
+ * <p>Get a hashCode for an array handling multi-dimensional arrays correctly.</p>
+ *
+ * <p>Multi-dimensional primitive arrays are also handled correctly by this method.</p>
+ *
+ * @param array the array to get a hashCode for, may be <code>null</code>
+ * @return a hashCode for the array
+ */
+ public static int hashCode(Object array) {
+ return new HashCodeBuilder().append(array).toHashCode();
+ }
+
+ /**
+ * <p>Compares two arrays, using equals(), handling multi-dimensional arrays
+ * correctly.</p>
+ *
+ * <p>Multi-dimensional primitive arrays are also handled correctly by this method.</p>
+ *
+ * @param array1 the array to get a hashCode for, may be <code>null</code>
+ * @param array2 the array to get a hashCode for, may be <code>null</code>
+ * @return <code>true</code> if the arrays are equal
+ */
+ public static boolean isEquals(Object array1, Object array2) {
+ return new EqualsBuilder().append(array1, array2).isEquals();
+ }
+
+ //--------------------------------------------------------------------------
+
+ /**
* <p>Converts the given array into a {@link Map}. Each element of the array
* must be either a {@link Map.Entry} or an Array, containing at least two
* elements, where the first element is used as key and the second as
@@ -298,9 +329,10 @@
* <p>Shallow clones an array returning a typecast result and handling
* <code>null</code>.</p>
*
- * <p>The objecs in the array are not cloned.</p>
+ * <p>The objecs in the array are not cloned, thus there is no special
+ * handling for multi-dimensional arrays.</p>
*
- * @param array the array to shallow clone, may not be <code>null</code>
+ * @param array the array to shallow clone, may be <code>null</code>
* @return the cloned array, or <code>null</code> if <code>null</code>
* passed in
*/
@@ -314,8 +346,10 @@
/**
* <p>Clones an array returning a typecast result and handling
* <code>null</code>.</p>
+ *
+ * <p>Any multi-dimensional aspects of the arrays are ignored.</p>
*
- * @param array the array to clone, may not be <code>null</code>
+ * @param array the array to clone, may be <code>null</code>
* @return the cloned array, or <code>null</code> if <code>null</code>
* passed in
*/
@@ -329,8 +363,10 @@
/**
* <p>Clones an array returning a typecast result and handling
* <code>null</code>.</p>
+ *
+ * <p>Any multi-dimensional aspects of the arrays are ignored.</p>
*
- * @param array the array to clone, may not be <code>null</code>
+ * @param array the array to clone, may be <code>null</code>
* @return the cloned array, or <code>null</code> if <code>null</code>
* passed in
*/
@@ -344,8 +380,10 @@
/**
* <p>Clones an array returning a typecast result and handling
* <code>null</code>.</p>
+ *
+ * <p>Any multi-dimensional aspects of the arrays are ignored.</p>
*
- * @param array the array to clone, may not be <code>null</code>
+ * @param array the array to clone, may be <code>null</code>
* @return the cloned array, or <code>null</code> if <code>null</code>
* passed in
*/
@@ -359,8 +397,27 @@
/**
* <p>Clones an array returning a typecast result and handling
* <code>null</code>.</p>
+ *
+ * <p>Any multi-dimensional aspects of the arrays are ignored.</p>
*
- * @param array the array to clone, may not be <code>null</code>
+ * @param array the array to clone, may be <code>null</code>
+ * @return the cloned array, or <code>null</code> if <code>null</code>
+ * passed in
+ */
+ public static char[] clone(char[] array) {
+ if (array == null) {
+ return null;
+ }
+ return (char[]) array.clone();
+ }
+
+ /**
+ * <p>Clones an array returning a typecast result and handling
+ * <code>null</code>.</p>
+ *
+ * <p>Any multi-dimensional aspects of the arrays are ignored.</p>
+ *
+ * @param array the array to clone, may be <code>null</code>
* @return the cloned array, or <code>null</code> if <code>null</code>
* passed in
*/
@@ -374,8 +431,10 @@
/**
* <p>Clones an array returning a typecast result and handling
* <code>null</code>.</p>
+ *
+ * <p>Any multi-dimensional aspects of the arrays are ignored.</p>
*
- * @param array the array to clone, may not be <code>null</code>
+ * @param array the array to clone, may be <code>null</code>
* @return the cloned array, or <code>null</code> if <code>null</code>
* passed in
*/
@@ -389,8 +448,10 @@
/**
* <p>Clones an array returning a typecast result and handling
* <code>null</code>.</p>
+ *
+ * <p>Any multi-dimensional aspects of the arrays are ignored.</p>
*
- * @param array the array to clone, may not be <code>null</code>
+ * @param array the array to clone, may be <code>null</code>
* @return the cloned array, or <code>null</code> if <code>null</code>
* passed in
*/
@@ -404,8 +465,10 @@
/**
* <p>Clones an array returning a typecast result and handling
* <code>null</code>.</p>
+ *
+ * <p>Any multi-dimensional aspects of the arrays are ignored.</p>
*
- * @param array the array to clone, may not be <code>null</code>
+ * @param array the array to clone, may be <code>null</code>
* @return the cloned array, or <code>null</code> if <code>null</code>
* passed in
*/
@@ -509,6 +572,26 @@
* @return <code>true</code> if length of arrays matches, treating
* <code>null</code> as an empty array
*/
+ public static boolean isSameLength(char[] array1, char[] array2) {
+ if ((array1 == null && array2 != null && array2.length > 0) ||
+ (array2 == null && array1 != null && array1.length > 0) ||
+ (array1 != null && array2 != null && array1.length != array2.length)) {
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * <p>Checks whether two arrays are the same length, treating
+ * <code>null</code> arrays as length <code>0</code>.</p>
+ *
+ * <p>Any multi-dimensional aspects of the arrays are ignored.</p>
+ *
+ * @param array1 the first array, may be <code>null</code>
+ * @param array2 the second array, may be <code>null</code>
+ * @return <code>true</code> if length of arrays matches, treating
+ * <code>null</code> as an empty array
+ */
public static boolean isSameLength(byte[] array1, byte[] array2) {
if ((array1 == null && array2 != null && array2.length > 0) ||
(array2 == null && array1 != null && array1.length > 0) ||
@@ -581,6 +664,8 @@
/**
* <p>Checks whether two arrays are the same type taking into account
* multi-dimensional arrays.</p>
+ *
+ * <p>Primitive arrays may be compared using this method too.</p>
*
* @param array1 the first array, must not be <code>null</code>
* @param array2 the second array, must not be <code>null</code>
1.2 +384 -16 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.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- ArrayUtilsTest.java 13 Oct 2002 22:42:59 -0000 1.1
+++ ArrayUtilsTest.java 16 Nov 2002 12:56:44 -0000 1.2
@@ -54,6 +54,7 @@
* <http://www.apache.org/>.
*/
+import java.util.Arrays;
import java.util.Map;
import junit.framework.Test;
@@ -92,7 +93,47 @@
}
//-----------------------------------------------------------------------
+ public void testToString() {
+ assertEquals("{}", ArrayUtils.toString(null));
+ assertEquals("{}", ArrayUtils.toString(new Object[0]));
+ assertEquals("{}", ArrayUtils.toString(new String[0]));
+ assertEquals("{<null>}", ArrayUtils.toString(new String[] {null}));
+ assertEquals("{pink,blue}", ArrayUtils.toString(new String[] {"pink","blue"}));
+
+ assertEquals("<empty>", ArrayUtils.toString(null, "<empty>"));
+ assertEquals("{}", ArrayUtils.toString(new Object[0], "<empty>"));
+ assertEquals("{}", ArrayUtils.toString(new String[0], "<empty>"));
+ assertEquals("{<null>}", ArrayUtils.toString(new String[] {null}, "<empty>"));
+ assertEquals("{pink,blue}", ArrayUtils.toString(new String[] {"pink","blue"}, "<empty>"));
+ }
+ //-----------------------------------------------------------------------
+ public void testHashCode() {
+ long[][] array1 = new long[][] {{2,5}, {4,5}};
+ long[][] array2 = new long[][] {{2,5}, {4,6}};
+ assertEquals(true, ArrayUtils.hashCode(array1) == ArrayUtils.hashCode(array1));
+ assertEquals(false, ArrayUtils.hashCode(array1) == ArrayUtils.hashCode(array2));
+
+ Object[] array3 = new Object[] {new String(new char[] {'A', 'B'})};
+ Object[] array4 = new Object[] {"AB"};
+ assertEquals(true, ArrayUtils.hashCode(array3) == ArrayUtils.hashCode(array3));
+ assertEquals(true, ArrayUtils.hashCode(array3) == ArrayUtils.hashCode(array4));
+ }
+
+ //-----------------------------------------------------------------------
+ public void testIsEquals() {
+ long[][] array1 = new long[][] {{2,5}, {4,5}};
+ long[][] array2 = new long[][] {{2,5}, {4,6}};
+ assertEquals(true, ArrayUtils.isEquals(array1, array1));
+ assertEquals(false, ArrayUtils.isEquals(array1, array2));
+
+ Object[] array3 = new Object[] {new String(new char[] {'A', 'B'})};
+ Object[] array4 = new Object[] {"AB"};
+ assertEquals(true, ArrayUtils.isEquals(array3, array3));
+ assertEquals(true, ArrayUtils.isEquals(array3, array4));
+ }
+
+ //-----------------------------------------------------------------------
public void testToMap() {
Map map = ArrayUtils.toMap(new String[][] {{"foo", "bar"}, {"hello", "world"}});
@@ -102,30 +143,19 @@
try {
ArrayUtils.toMap(null);
fail("exception expected");
- } catch (IllegalArgumentException e) {
- // expected.
- }
-
+ } catch (IllegalArgumentException ex) {}
try {
ArrayUtils.toMap(new String[][] {{"foo", "bar"}, {"short"}});
fail("exception expected");
- } catch (IllegalArgumentException e) {
- // expected.
- }
-
+ } catch (IllegalArgumentException ex) {}
try {
ArrayUtils.toMap(new Object[] {new Object[] {"foo", "bar"}, "illegal type"});
fail("exception expected");
- } catch (IllegalArgumentException e) {
- // expected.
- }
-
+ } catch (IllegalArgumentException ex) {}
try {
ArrayUtils.toMap(new Object[] {new Object[] {"foo", "bar"}, null});
fail("exception expected");
- } catch (IllegalArgumentException e) {
- // expected.
- }
+ } catch (IllegalArgumentException ex) {}
map = ArrayUtils.toMap(new Object[] {new Map.Entry() {
public Object getKey() {
@@ -147,6 +177,344 @@
assertEquals("bar", map.get("foo"));
}
+ //-----------------------------------------------------------------------
+ public void testClone() {
+ assertEquals(null, ArrayUtils.clone((Object[]) null));
+ Object[] original1 = new Object[0];
+ Object[] cloned1 = ArrayUtils.clone(original1);
+ assertTrue(Arrays.equals(original1, cloned1));
+ assertTrue(original1 != cloned1);
+
+ StringBuffer buf = new StringBuffer("pick");
+ original1 = new Object[] {buf, "a", new String[] {"stick"}};
+ cloned1 = ArrayUtils.clone(original1);
+ assertTrue(Arrays.equals(original1, cloned1));
+ assertTrue(original1 != cloned1);
+ assertSame(original1[0], cloned1[0]);
+ assertSame(original1[1], cloned1[1]);
+ assertSame(original1[2], cloned1[2]);
+ }
+
+ public void testCloneBoolean() {
+ boolean[] original = new boolean[] {true, false};
+ boolean[] cloned = ArrayUtils.clone(original);
+ assertTrue(Arrays.equals(original, cloned));
+ assertTrue(original != cloned);
+ }
+
+ public void testCloneLong() {
+ long[] original = new long[] {0L, 1L};
+ long[] cloned = ArrayUtils.clone(original);
+ assertTrue(Arrays.equals(original, cloned));
+ assertTrue(original != cloned);
+ }
+
+ public void testCloneInt() {
+ int[] original = new int[] {5, 8};
+ int[] cloned = ArrayUtils.clone(original);
+ assertTrue(Arrays.equals(original, cloned));
+ assertTrue(original != cloned);
+ }
+
+ public void testCloneShort() {
+ short[] original = new short[] {1, 4};
+ short[] cloned = ArrayUtils.clone(original);
+ assertTrue(Arrays.equals(original, cloned));
+ assertTrue(original != cloned);
+ }
+
+ public void testCloneChar() {
+ char[] original = new char[] {'a', '4'};
+ char[] cloned = ArrayUtils.clone(original);
+ assertTrue(Arrays.equals(original, cloned));
+ assertTrue(original != cloned);
+ }
+
+ public void testCloneByte() {
+ byte[] original = new byte[] {1, 6};
+ byte[] cloned = ArrayUtils.clone(original);
+ assertTrue(Arrays.equals(original, cloned));
+ assertTrue(original != cloned);
+ }
+
+ public void testCloneDouble() {
+ double[] original = new double[] {2.4d, 5.7d};
+ double[] cloned = ArrayUtils.clone(original);
+ assertTrue(Arrays.equals(original, cloned));
+ assertTrue(original != cloned);
+ }
+
+ public void testCloneFloat() {
+ float[] original = new float[] {2.6f, 6.4f};
+ float[] cloned = ArrayUtils.clone(original);
+ assertTrue(Arrays.equals(original, cloned));
+ assertTrue(original != cloned);
+ }
+ //-----------------------------------------------------------------------
+ public void testSameLength() {
+ Object[] nullArray = null;
+ Object[] emptyArray = new Object[0];
+ Object[] oneArray = new Object[] {"pick"};
+ Object[] twoArray = new Object[] {"pick", "stick"};
+
+ assertEquals(true, ArrayUtils.isSameLength(nullArray, nullArray));
+ assertEquals(true, ArrayUtils.isSameLength(nullArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(nullArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(nullArray, twoArray));
+
+ assertEquals(true, ArrayUtils.isSameLength(emptyArray, nullArray));
+ assertEquals(true, ArrayUtils.isSameLength(emptyArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(emptyArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(emptyArray, twoArray));
+
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, nullArray));
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, emptyArray));
+ assertEquals(true, ArrayUtils.isSameLength(oneArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, twoArray));
+
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, nullArray));
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, oneArray));
+ assertEquals(true, ArrayUtils.isSameLength(twoArray, twoArray));
+ }
+ public void testSameLengthBoolean() {
+ boolean[] nullArray = null;
+ boolean[] emptyArray = new boolean[0];
+ boolean[] oneArray = new boolean[] {true};
+ boolean[] twoArray = new boolean[] {true, false};
+
+ assertEquals(true, ArrayUtils.isSameLength(nullArray, nullArray));
+ assertEquals(true, ArrayUtils.isSameLength(nullArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(nullArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(nullArray, twoArray));
+
+ assertEquals(true, ArrayUtils.isSameLength(emptyArray, nullArray));
+ assertEquals(true, ArrayUtils.isSameLength(emptyArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(emptyArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(emptyArray, twoArray));
+
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, nullArray));
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, emptyArray));
+ assertEquals(true, ArrayUtils.isSameLength(oneArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, twoArray));
+
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, nullArray));
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, oneArray));
+ assertEquals(true, ArrayUtils.isSameLength(twoArray, twoArray));
+ }
+
+ public void testSameLengthLong() {
+ long[] nullArray = null;
+ long[] emptyArray = new long[0];
+ long[] oneArray = new long[] {0L};
+ long[] twoArray = new long[] {0L, 76L};
+
+ assertEquals(true, ArrayUtils.isSameLength(nullArray, nullArray));
+ assertEquals(true, ArrayUtils.isSameLength(nullArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(nullArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(nullArray, twoArray));
+
+ assertEquals(true, ArrayUtils.isSameLength(emptyArray, nullArray));
+ assertEquals(true, ArrayUtils.isSameLength(emptyArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(emptyArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(emptyArray, twoArray));
+
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, nullArray));
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, emptyArray));
+ assertEquals(true, ArrayUtils.isSameLength(oneArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, twoArray));
+
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, nullArray));
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, oneArray));
+ assertEquals(true, ArrayUtils.isSameLength(twoArray, twoArray));
+ }
+
+ public void testSameLengthInt() {
+ int[] nullArray = null;
+ int[] emptyArray = new int[0];
+ int[] oneArray = new int[] {4};
+ int[] twoArray = new int[] {5, 7};
+
+ assertEquals(true, ArrayUtils.isSameLength(nullArray, nullArray));
+ assertEquals(true, ArrayUtils.isSameLength(nullArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(nullArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(nullArray, twoArray));
+
+ assertEquals(true, ArrayUtils.isSameLength(emptyArray, nullArray));
+ assertEquals(true, ArrayUtils.isSameLength(emptyArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(emptyArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(emptyArray, twoArray));
+
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, nullArray));
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, emptyArray));
+ assertEquals(true, ArrayUtils.isSameLength(oneArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, twoArray));
+
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, nullArray));
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, oneArray));
+ assertEquals(true, ArrayUtils.isSameLength(twoArray, twoArray));
+ }
+
+ public void testSameLengthShort() {
+ short[] nullArray = null;
+ short[] emptyArray = new short[0];
+ short[] oneArray = new short[] {4};
+ short[] twoArray = new short[] {6, 8};
+
+ assertEquals(true, ArrayUtils.isSameLength(nullArray, nullArray));
+ assertEquals(true, ArrayUtils.isSameLength(nullArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(nullArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(nullArray, twoArray));
+
+ assertEquals(true, ArrayUtils.isSameLength(emptyArray, nullArray));
+ assertEquals(true, ArrayUtils.isSameLength(emptyArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(emptyArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(emptyArray, twoArray));
+
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, nullArray));
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, emptyArray));
+ assertEquals(true, ArrayUtils.isSameLength(oneArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, twoArray));
+
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, nullArray));
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, oneArray));
+ assertEquals(true, ArrayUtils.isSameLength(twoArray, twoArray));
+ }
+
+ public void testSameLengthChar() {
+ char[] nullArray = null;
+ char[] emptyArray = new char[0];
+ char[] oneArray = new char[] {'f'};
+ char[] twoArray = new char[] {'d', 't'};
+
+ assertEquals(true, ArrayUtils.isSameLength(nullArray, nullArray));
+ assertEquals(true, ArrayUtils.isSameLength(nullArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(nullArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(nullArray, twoArray));
+
+ assertEquals(true, ArrayUtils.isSameLength(emptyArray, nullArray));
+ assertEquals(true, ArrayUtils.isSameLength(emptyArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(emptyArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(emptyArray, twoArray));
+
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, nullArray));
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, emptyArray));
+ assertEquals(true, ArrayUtils.isSameLength(oneArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, twoArray));
+
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, nullArray));
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, oneArray));
+ assertEquals(true, ArrayUtils.isSameLength(twoArray, twoArray));
+ }
+
+ public void testSameLengthByte() {
+ byte[] nullArray = null;
+ byte[] emptyArray = new byte[0];
+ byte[] oneArray = new byte[] {3};
+ byte[] twoArray = new byte[] {4, 6};
+
+ assertEquals(true, ArrayUtils.isSameLength(nullArray, nullArray));
+ assertEquals(true, ArrayUtils.isSameLength(nullArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(nullArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(nullArray, twoArray));
+
+ assertEquals(true, ArrayUtils.isSameLength(emptyArray, nullArray));
+ assertEquals(true, ArrayUtils.isSameLength(emptyArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(emptyArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(emptyArray, twoArray));
+
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, nullArray));
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, emptyArray));
+ assertEquals(true, ArrayUtils.isSameLength(oneArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, twoArray));
+
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, nullArray));
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, oneArray));
+ assertEquals(true, ArrayUtils.isSameLength(twoArray, twoArray));
+ }
+
+ public void testSameLengthDouble() {
+ double[] nullArray = null;
+ double[] emptyArray = new double[0];
+ double[] oneArray = new double[] {1.3d};
+ double[] twoArray = new double[] {4.5d, 6.3d};
+
+ assertEquals(true, ArrayUtils.isSameLength(nullArray, nullArray));
+ assertEquals(true, ArrayUtils.isSameLength(nullArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(nullArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(nullArray, twoArray));
+
+ assertEquals(true, ArrayUtils.isSameLength(emptyArray, nullArray));
+ assertEquals(true, ArrayUtils.isSameLength(emptyArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(emptyArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(emptyArray, twoArray));
+
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, nullArray));
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, emptyArray));
+ assertEquals(true, ArrayUtils.isSameLength(oneArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, twoArray));
+
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, nullArray));
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, oneArray));
+ assertEquals(true, ArrayUtils.isSameLength(twoArray, twoArray));
+ }
+
+ public void testSameLengthFloat() {
+ float[] nullArray = null;
+ float[] emptyArray = new float[0];
+ float[] oneArray = new float[] {2.5f};
+ float[] twoArray = new float[] {6.4f, 5.8f};
+
+ assertEquals(true, ArrayUtils.isSameLength(nullArray, nullArray));
+ assertEquals(true, ArrayUtils.isSameLength(nullArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(nullArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(nullArray, twoArray));
+
+ assertEquals(true, ArrayUtils.isSameLength(emptyArray, nullArray));
+ assertEquals(true, ArrayUtils.isSameLength(emptyArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(emptyArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(emptyArray, twoArray));
+
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, nullArray));
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, emptyArray));
+ assertEquals(true, ArrayUtils.isSameLength(oneArray, oneArray));
+ assertEquals(false, ArrayUtils.isSameLength(oneArray, twoArray));
+
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, nullArray));
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, emptyArray));
+ assertEquals(false, ArrayUtils.isSameLength(twoArray, oneArray));
+ assertEquals(true, ArrayUtils.isSameLength(twoArray, twoArray));
+ }
+
+ //-----------------------------------------------------------------------
+ public void testSameType() {
+ try {
+ ArrayUtils.isSameType(null, null);
+ fail();
+ } catch (IllegalArgumentException ex) {}
+ try {
+ ArrayUtils.isSameType(null, new Object[0]);
+ fail();
+ } catch (IllegalArgumentException ex) {}
+ try {
+ ArrayUtils.isSameType(new Object[0], null);
+ fail();
+ } catch (IllegalArgumentException ex) {}
+
+ assertEquals(true, ArrayUtils.isSameType(new Object[0], new Object[0]));
+ assertEquals(false, ArrayUtils.isSameType(new String[0], new Object[0]));
+ assertEquals(true, ArrayUtils.isSameType(new String[0][0], new String[0][0]));
+ assertEquals(false, ArrayUtils.isSameType(new String[0], new String[0][0]));
+ assertEquals(false, ArrayUtils.isSameType(new String[0][0], new String[0]));
+ }
+
}
--
To unsubscribe, e-mail: <ma...@jakarta.apache.org>
For additional commands, e-mail: <ma...@jakarta.apache.org>