Google Git
Sign in
apache / commons-lang / refs/heads/LANG_POST_2_4 / . / src / test / org / apache / commons / lang / ArrayUtilsTest.java
blob: a7a25973b0fe1e7cb80fe614b1266afa73c16e55 [file] [log] [blame]
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.lang;
import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
import java.util.Arrays;
import java.util.Date;
import java.util.Map;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import junit.textui.TestRunner;
/**
* Unit tests {@link org.apache.commons.lang.ArrayUtils}.
*
* @author Stephen Colebourne
* @author Moritz Petersen
* @author Nikolay Metchev
* @author Matthew Hawthorne
* @author Tim O'Brien
* @author <a href="mailto:equinus100@hotmail.com">Ashwin S</a>
* @author Fredrik Westermarck
* @author Gary Gregory
* @author Maarten Coene
* @version $Id$
*/
public class ArrayUtilsTest extends TestCase {
public ArrayUtilsTest(String name) {
super(name);
}
public static void main(String[] args) {
TestRunner.run(suite());
}
public static Test suite() {
TestSuite suite = new TestSuite(ArrayUtilsTest.class);
suite.setName("ArrayUtils Tests");
return suite;
}
protected void setUp() throws Exception {
super.setUp();
}
protected void tearDown() throws Exception {
super.tearDown();
}
//-----------------------------------------------------------------------
public void testConstructor() {
assertNotNull(new ArrayUtils());
Constructor[] cons = ArrayUtils.class.getDeclaredConstructors();
assertEquals(1, cons.length);
assertEquals(true, Modifier.isPublic(cons[0].getModifiers()));
assertEquals(true, Modifier.isPublic(ArrayUtils.class.getModifiers()));
assertEquals(false, Modifier.isFinal(ArrayUtils.class.getModifiers()));
}
//-----------------------------------------------------------------------
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));
}
//-----------------------------------------------------------------------
private void assertIsEquals(Object array1, Object array2, Object array3) {
assertEquals(true, ArrayUtils.isEquals(array1, array1));
assertEquals(true, ArrayUtils.isEquals(array2, array2));
assertEquals(true, ArrayUtils.isEquals(array3, array3));
assertEquals(false, ArrayUtils.isEquals(array1, array2));
assertEquals(false, ArrayUtils.isEquals(array2, array1));
assertEquals(false, ArrayUtils.isEquals(array1, array3));
assertEquals(false, ArrayUtils.isEquals(array3, array1));
assertEquals(false, ArrayUtils.isEquals(array1, array2));
assertEquals(false, ArrayUtils.isEquals(array2, array1));
}
public void testIsEquals() {
long[][] larray1 = new long[][]{{2, 5}, {4, 5}};
long[][] larray2 = new long[][]{{2, 5}, {4, 6}};
long[] larray3 = new long[]{2, 5};
this.assertIsEquals(larray1, larray2, larray3);
int[][] iarray1 = new int[][]{{2, 5}, {4, 5}};
int[][] iarray2 = new int[][]{{2, 5}, {4, 6}};
int[] iarray3 = new int[]{2, 5};
this.assertIsEquals(iarray1, iarray2, iarray3);
short[][] sarray1 = new short[][]{{2, 5}, {4, 5}};
short[][] sarray2 = new short[][]{{2, 5}, {4, 6}};
short[] sarray3 = new short[]{2, 5};
this.assertIsEquals(sarray1, sarray2, sarray3);
float[][] farray1 = new float[][]{{2, 5}, {4, 5}};
float[][] farray2 = new float[][]{{2, 5}, {4, 6}};
float[] farray3 = new float[]{2, 5};
this.assertIsEquals(farray1, farray2, farray3);
double[][] darray1 = new double[][]{{2, 5}, {4, 5}};
double[][] darray2 = new double[][]{{2, 5}, {4, 6}};
double[] darray3 = new double[]{2, 5};
this.assertIsEquals(darray1, darray2, darray3);
byte[][] byteArray1 = new byte[][]{{2, 5}, {4, 5}};
byte[][] byteArray2 = new byte[][]{{2, 5}, {4, 6}};
byte[] byteArray3 = new byte[]{2, 5};
this.assertIsEquals(byteArray1, byteArray2, byteArray3);
char[][] charArray1 = new char[][]{{2, 5}, {4, 5}};
char[][] charArray2 = new char[][]{{2, 5}, {4, 6}};
char[] charArray3 = new char[]{2, 5};
this.assertIsEquals(charArray1, charArray2, charArray3);
boolean[][] barray1 = new boolean[][]{{true, false}, {true, true}};
boolean[][] barray2 = new boolean[][]{{true, false}, {true, false}};
boolean[] barray3 = new boolean[]{false, true};
this.assertIsEquals(barray1, barray2, barray3);
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));
assertEquals(true, ArrayUtils.isEquals(null, null));
assertEquals(false, ArrayUtils.isEquals(null, array4));
}
//-----------------------------------------------------------------------
public void testToMap() {
Map map = ArrayUtils.toMap(new String[][] {{"foo", "bar"}, {"hello", "world"}});
assertEquals("bar", map.get("foo"));
assertEquals("world", map.get("hello"));
assertEquals(null, ArrayUtils.toMap(null));
try {
ArrayUtils.toMap(new String[][] {{"foo", "bar"}, {"short"}});
fail("exception expected");
} catch (IllegalArgumentException ex) {}
try {
ArrayUtils.toMap(new Object[] {new Object[] {"foo", "bar"}, "illegal type"});
fail("exception expected");
} catch (IllegalArgumentException ex) {}
try {
ArrayUtils.toMap(new Object[] {new Object[] {"foo", "bar"}, null});
fail("exception expected");
} catch (IllegalArgumentException ex) {}
map = ArrayUtils.toMap(new Object[] {new Map.Entry() {
public Object getKey() {
return "foo";
}
public Object getValue() {
return "bar";
}
public Object setValue(Object value) {
throw new UnsupportedOperationException();
}
public boolean equals(Object o) {
throw new UnsupportedOperationException();
}
public int hashCode() {
throw new UnsupportedOperationException();
}
}});
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() {
assertEquals(null, ArrayUtils.clone((boolean[]) null));
boolean[] original = new boolean[] {true, false};
boolean[] cloned = ArrayUtils.clone(original);
assertTrue(Arrays.equals(original, cloned));
assertTrue(original != cloned);
}
public void testCloneLong() {
assertEquals(null, ArrayUtils.clone((long[]) null));
long[] original = new long[] {0L, 1L};
long[] cloned = ArrayUtils.clone(original);
assertTrue(Arrays.equals(original, cloned));
assertTrue(original != cloned);
}
public void testCloneInt() {
assertEquals(null, ArrayUtils.clone((int[]) null));
int[] original = new int[] {5, 8};
int[] cloned = ArrayUtils.clone(original);
assertTrue(Arrays.equals(original, cloned));
assertTrue(original != cloned);
}
public void testCloneShort() {
assertEquals(null, ArrayUtils.clone((short[]) null));
short[] original = new short[] {1, 4};
short[] cloned = ArrayUtils.clone(original);
assertTrue(Arrays.equals(original, cloned));
assertTrue(original != cloned);
}
public void testCloneChar() {
assertEquals(null, ArrayUtils.clone((char[]) null));
char[] original = new char[] {'a', '4'};
char[] cloned = ArrayUtils.clone(original);
assertTrue(Arrays.equals(original, cloned));
assertTrue(original != cloned);
}
public void testCloneByte() {
assertEquals(null, ArrayUtils.clone((byte[]) null));
byte[] original = new byte[] {1, 6};
byte[] cloned = ArrayUtils.clone(original);
assertTrue(Arrays.equals(original, cloned));
assertTrue(original != cloned);
}
public void testCloneDouble() {
assertEquals(null, ArrayUtils.clone((double[]) null));
double[] original = new double[] {2.4d, 5.7d};
double[] cloned = ArrayUtils.clone(original);
assertTrue(Arrays.equals(original, cloned));
assertTrue(original != cloned);
}
public void testCloneFloat() {
assertEquals(null, ArrayUtils.clone((float[]) null));
float[] original = new float[] {2.6f, 6.4f};
float[] cloned = ArrayUtils.clone(original);
assertTrue(Arrays.equals(original, cloned));
assertTrue(original != cloned);
}
//-----------------------------------------------------------------------
public void testSubarrayObject() {
Object[] nullArray = null;
Object[] objectArray = { "a", "b", "c", "d", "e", "f"};
assertEquals("0 start, mid end", "abcd",
StringUtils.join(ArrayUtils.subarray(objectArray, 0, 4)));
assertEquals("0 start, length end", "abcdef",
StringUtils.join(ArrayUtils.subarray(objectArray, 0, objectArray.length)));
assertEquals("mid start, mid end", "bcd",
StringUtils.join(ArrayUtils.subarray(objectArray, 1, 4)));
assertEquals("mid start, length end", "bcdef",
StringUtils.join(ArrayUtils.subarray(objectArray, 1, objectArray.length)));
assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3));
assertEquals("empty array", "",
StringUtils.join(ArrayUtils.subarray(ArrayUtils.EMPTY_OBJECT_ARRAY, 1, 2)));
assertEquals("start > end", "",
StringUtils.join(ArrayUtils.subarray(objectArray, 4, 2)));
assertEquals("start == end", "",
StringUtils.join(ArrayUtils.subarray(objectArray, 3, 3)));
assertEquals("start undershoot, normal end", "abcd",
StringUtils.join(ArrayUtils.subarray(objectArray, -2, 4)));
assertEquals("start overshoot, any end", "",
StringUtils.join(ArrayUtils.subarray(objectArray, 33, 4)));
assertEquals("normal start, end overshoot", "cdef",
StringUtils.join(ArrayUtils.subarray(objectArray, 2, 33)));
assertEquals("start undershoot, end overshoot", "abcdef",
StringUtils.join(ArrayUtils.subarray(objectArray, -2, 12)));
// array type tests
Date[] dateArray = { new java.sql.Date(new Date().getTime()),
new Date(), new Date(), new Date(), new Date() };
assertSame("Object type", Object.class,
ArrayUtils.subarray(objectArray, 2, 4).getClass().getComponentType());
assertSame("java.util.Date type", java.util.Date.class,
ArrayUtils.subarray(dateArray, 1, 4).getClass().getComponentType());
assertNotSame("java.sql.Date type", java.sql.Date.class,
ArrayUtils.subarray(dateArray, 1, 4).getClass().getComponentType());
try {
Object dummy = (java.sql.Date[])ArrayUtils.subarray(dateArray, 1,3);
fail("Invalid downcast");
} catch (ClassCastException e) {}
}
public void testSubarrayLong() {
long[] nullArray = null;
long[] array = { 999910, 999911, 999912, 999913, 999914, 999915 };
long[] leftSubarray = { 999910, 999911, 999912, 999913 };
long[] midSubarray = { 999911, 999912, 999913, 999914 };
long[] rightSubarray = { 999912, 999913, 999914, 999915 };
assertTrue("0 start, mid end",
ArrayUtils.isEquals(leftSubarray,
ArrayUtils.subarray(array, 0, 4)));
assertTrue("0 start, length end",
ArrayUtils.isEquals(array,
ArrayUtils.subarray(array, 0, array.length)));
assertTrue("mid start, mid end",
ArrayUtils.isEquals(midSubarray,
ArrayUtils.subarray(array, 1, 5)));
assertTrue("mid start, length end",
ArrayUtils.isEquals(rightSubarray,
ArrayUtils.subarray(array, 2, array.length)));
assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3));
assertEquals("empty array", ArrayUtils.EMPTY_LONG_ARRAY,
ArrayUtils.subarray(ArrayUtils.EMPTY_LONG_ARRAY, 1, 2));
assertEquals("start > end", ArrayUtils.EMPTY_LONG_ARRAY,
ArrayUtils.subarray(array, 4, 2));
assertEquals("start == end", ArrayUtils.EMPTY_LONG_ARRAY,
ArrayUtils.subarray(array, 3, 3));
assertTrue("start undershoot, normal end",
ArrayUtils.isEquals(leftSubarray,
ArrayUtils.subarray(array, -2, 4)));
assertEquals("start overshoot, any end",
ArrayUtils.EMPTY_LONG_ARRAY,
ArrayUtils.subarray(array, 33, 4));
assertTrue("normal start, end overshoot",
ArrayUtils.isEquals(rightSubarray,
ArrayUtils.subarray(array, 2, 33)));
assertTrue("start undershoot, end overshoot",
ArrayUtils.isEquals(array,
ArrayUtils.subarray(array, -2, 12)));
// empty-return tests
assertSame("empty array, object test",
ArrayUtils.EMPTY_LONG_ARRAY,
ArrayUtils.subarray(ArrayUtils.EMPTY_LONG_ARRAY, 1, 2));
assertSame("start > end, object test",
ArrayUtils.EMPTY_LONG_ARRAY,
ArrayUtils.subarray(array, 4, 1));
assertSame("start == end, object test",
ArrayUtils.EMPTY_LONG_ARRAY,
ArrayUtils.subarray(array, 3, 3));
assertSame("start overshoot, any end, object test",
ArrayUtils.EMPTY_LONG_ARRAY,
ArrayUtils.subarray(array, 8733, 4));
// array type tests
assertSame("long type", long.class,
ArrayUtils.subarray(array, 2, 4).getClass().getComponentType());
}
public void testSubarrayInt() {
int[] nullArray = null;
int[] array = { 10, 11, 12, 13, 14, 15 };
int[] leftSubarray = { 10, 11, 12, 13 };
int[] midSubarray = { 11, 12, 13, 14 };
int[] rightSubarray = { 12, 13, 14, 15 };
assertTrue("0 start, mid end",
ArrayUtils.isEquals(leftSubarray,
ArrayUtils.subarray(array, 0, 4)));
assertTrue("0 start, length end",
ArrayUtils.isEquals(array,
ArrayUtils.subarray(array, 0, array.length)));
assertTrue("mid start, mid end",
ArrayUtils.isEquals(midSubarray,
ArrayUtils.subarray(array, 1, 5)));
assertTrue("mid start, length end",
ArrayUtils.isEquals(rightSubarray,
ArrayUtils.subarray(array, 2, array.length)));
assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3));
assertEquals("empty array", ArrayUtils.EMPTY_INT_ARRAY,
ArrayUtils.subarray(ArrayUtils.EMPTY_INT_ARRAY, 1, 2));
assertEquals("start > end", ArrayUtils.EMPTY_INT_ARRAY,
ArrayUtils.subarray(array, 4, 2));
assertEquals("start == end", ArrayUtils.EMPTY_INT_ARRAY,
ArrayUtils.subarray(array, 3, 3));
assertTrue("start undershoot, normal end",
ArrayUtils.isEquals(leftSubarray,
ArrayUtils.subarray(array, -2, 4)));
assertEquals("start overshoot, any end",
ArrayUtils.EMPTY_INT_ARRAY,
ArrayUtils.subarray(array, 33, 4));
assertTrue("normal start, end overshoot",
ArrayUtils.isEquals(rightSubarray,
ArrayUtils.subarray(array, 2, 33)));
assertTrue("start undershoot, end overshoot",
ArrayUtils.isEquals(array,
ArrayUtils.subarray(array, -2, 12)));
// empty-return tests
assertSame("empty array, object test",
ArrayUtils.EMPTY_INT_ARRAY,
ArrayUtils.subarray(ArrayUtils.EMPTY_INT_ARRAY, 1, 2));
assertSame("start > end, object test",
ArrayUtils.EMPTY_INT_ARRAY,
ArrayUtils.subarray(array, 4, 1));
assertSame("start == end, object test",
ArrayUtils.EMPTY_INT_ARRAY,
ArrayUtils.subarray(array, 3, 3));
assertSame("start overshoot, any end, object test",
ArrayUtils.EMPTY_INT_ARRAY,
ArrayUtils.subarray(array, 8733, 4));
// array type tests
assertSame("int type", int.class,
ArrayUtils.subarray(array, 2, 4).getClass().getComponentType());
}
public void testSubarrayShort() {
short[] nullArray = null;
short[] array = { 10, 11, 12, 13, 14, 15 };
short[] leftSubarray = { 10, 11, 12, 13 };
short[] midSubarray = { 11, 12, 13, 14 };
short[] rightSubarray = { 12, 13, 14, 15 };
assertTrue("0 start, mid end",
ArrayUtils.isEquals(leftSubarray,
ArrayUtils.subarray(array, 0, 4)));
assertTrue("0 start, length end",
ArrayUtils.isEquals(array,
ArrayUtils.subarray(array, 0, array.length)));
assertTrue("mid start, mid end",
ArrayUtils.isEquals(midSubarray,
ArrayUtils.subarray(array, 1, 5)));
assertTrue("mid start, length end",
ArrayUtils.isEquals(rightSubarray,
ArrayUtils.subarray(array, 2, array.length)));
assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3));
assertEquals("empty array", ArrayUtils.EMPTY_SHORT_ARRAY,
ArrayUtils.subarray(ArrayUtils.EMPTY_SHORT_ARRAY, 1, 2));
assertEquals("start > end", ArrayUtils.EMPTY_SHORT_ARRAY,
ArrayUtils.subarray(array, 4, 2));
assertEquals("start == end", ArrayUtils.EMPTY_SHORT_ARRAY,
ArrayUtils.subarray(array, 3, 3));
assertTrue("start undershoot, normal end",
ArrayUtils.isEquals(leftSubarray,
ArrayUtils.subarray(array, -2, 4)));
assertEquals("start overshoot, any end",
ArrayUtils.EMPTY_SHORT_ARRAY,
ArrayUtils.subarray(array, 33, 4));
assertTrue("normal start, end overshoot",
ArrayUtils.isEquals(rightSubarray,
ArrayUtils.subarray(array, 2, 33)));
assertTrue("start undershoot, end overshoot",
ArrayUtils.isEquals(array,
ArrayUtils.subarray(array, -2, 12)));
// empty-return tests
assertSame("empty array, object test",
ArrayUtils.EMPTY_SHORT_ARRAY,
ArrayUtils.subarray(ArrayUtils.EMPTY_SHORT_ARRAY, 1, 2));
assertSame("start > end, object test",
ArrayUtils.EMPTY_SHORT_ARRAY,
ArrayUtils.subarray(array, 4, 1));
assertSame("start == end, object test",
ArrayUtils.EMPTY_SHORT_ARRAY,
ArrayUtils.subarray(array, 3, 3));
assertSame("start overshoot, any end, object test",
ArrayUtils.EMPTY_SHORT_ARRAY,
ArrayUtils.subarray(array, 8733, 4));
// array type tests
assertSame("short type", short.class,
ArrayUtils.subarray(array, 2, 4).getClass().getComponentType());
}
public void testSubarrChar() {
char[] nullArray = null;
char[] array = { 'a', 'b', 'c', 'd', 'e', 'f' };
char[] leftSubarray = { 'a', 'b', 'c', 'd', };
char[] midSubarray = { 'b', 'c', 'd', 'e', };
char[] rightSubarray = { 'c', 'd', 'e', 'f', };
assertTrue("0 start, mid end",
ArrayUtils.isEquals(leftSubarray,
ArrayUtils.subarray(array, 0, 4)));
assertTrue("0 start, length end",
ArrayUtils.isEquals(array,
ArrayUtils.subarray(array, 0, array.length)));
assertTrue("mid start, mid end",
ArrayUtils.isEquals(midSubarray,
ArrayUtils.subarray(array, 1, 5)));
assertTrue("mid start, length end",
ArrayUtils.isEquals(rightSubarray,
ArrayUtils.subarray(array, 2, array.length)));
assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3));
assertEquals("empty array", ArrayUtils.EMPTY_CHAR_ARRAY,
ArrayUtils.subarray(ArrayUtils.EMPTY_CHAR_ARRAY, 1, 2));
assertEquals("start > end", ArrayUtils.EMPTY_CHAR_ARRAY,
ArrayUtils.subarray(array, 4, 2));
assertEquals("start == end", ArrayUtils.EMPTY_CHAR_ARRAY,
ArrayUtils.subarray(array, 3, 3));
assertTrue("start undershoot, normal end",
ArrayUtils.isEquals(leftSubarray,
ArrayUtils.subarray(array, -2, 4)));
assertEquals("start overshoot, any end",
ArrayUtils.EMPTY_CHAR_ARRAY,
ArrayUtils.subarray(array, 33, 4));
assertTrue("normal start, end overshoot",
ArrayUtils.isEquals(rightSubarray,
ArrayUtils.subarray(array, 2, 33)));
assertTrue("start undershoot, end overshoot",
ArrayUtils.isEquals(array,
ArrayUtils.subarray(array, -2, 12)));
// empty-return tests
assertSame("empty array, object test",
ArrayUtils.EMPTY_CHAR_ARRAY,
ArrayUtils.subarray(ArrayUtils.EMPTY_CHAR_ARRAY, 1, 2));
assertSame("start > end, object test",
ArrayUtils.EMPTY_CHAR_ARRAY,
ArrayUtils.subarray(array, 4, 1));
assertSame("start == end, object test",
ArrayUtils.EMPTY_CHAR_ARRAY,
ArrayUtils.subarray(array, 3, 3));
assertSame("start overshoot, any end, object test",
ArrayUtils.EMPTY_CHAR_ARRAY,
ArrayUtils.subarray(array, 8733, 4));
// array type tests
assertSame("char type", char.class,
ArrayUtils.subarray(array, 2, 4).getClass().getComponentType());
}
public void testSubarrayByte() {
byte[] nullArray = null;
byte[] array = { 10, 11, 12, 13, 14, 15 };
byte[] leftSubarray = { 10, 11, 12, 13 };
byte[] midSubarray = { 11, 12, 13, 14 };
byte[] rightSubarray = { 12, 13, 14, 15 };
assertTrue("0 start, mid end",
ArrayUtils.isEquals(leftSubarray,
ArrayUtils.subarray(array, 0, 4)));
assertTrue("0 start, length end",
ArrayUtils.isEquals(array,
ArrayUtils.subarray(array, 0, array.length)));
assertTrue("mid start, mid end",
ArrayUtils.isEquals(midSubarray,
ArrayUtils.subarray(array, 1, 5)));
assertTrue("mid start, length end",
ArrayUtils.isEquals(rightSubarray,
ArrayUtils.subarray(array, 2, array.length)));
assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3));
assertEquals("empty array", ArrayUtils.EMPTY_BYTE_ARRAY,
ArrayUtils.subarray(ArrayUtils.EMPTY_BYTE_ARRAY, 1, 2));
assertEquals("start > end", ArrayUtils.EMPTY_BYTE_ARRAY,
ArrayUtils.subarray(array, 4, 2));
assertEquals("start == end", ArrayUtils.EMPTY_BYTE_ARRAY,
ArrayUtils.subarray(array, 3, 3));
assertTrue("start undershoot, normal end",
ArrayUtils.isEquals(leftSubarray,
ArrayUtils.subarray(array, -2, 4)));
assertEquals("start overshoot, any end",
ArrayUtils.EMPTY_BYTE_ARRAY,
ArrayUtils.subarray(array, 33, 4));
assertTrue("normal start, end overshoot",
ArrayUtils.isEquals(rightSubarray,
ArrayUtils.subarray(array, 2, 33)));
assertTrue("start undershoot, end overshoot",
ArrayUtils.isEquals(array,
ArrayUtils.subarray(array, -2, 12)));
// empty-return tests
assertSame("empty array, object test",
ArrayUtils.EMPTY_BYTE_ARRAY,
ArrayUtils.subarray(ArrayUtils.EMPTY_BYTE_ARRAY, 1, 2));
assertSame("start > end, object test",
ArrayUtils.EMPTY_BYTE_ARRAY,
ArrayUtils.subarray(array, 4, 1));
assertSame("start == end, object test",
ArrayUtils.EMPTY_BYTE_ARRAY,
ArrayUtils.subarray(array, 3, 3));
assertSame("start overshoot, any end, object test",
ArrayUtils.EMPTY_BYTE_ARRAY,
ArrayUtils.subarray(array, 8733, 4));
// array type tests
assertSame("byte type", byte.class,
ArrayUtils.subarray(array, 2, 4).getClass().getComponentType());
}
public void testSubarrayDouble() {
double[] nullArray = null;
double[] array = { 10.123, 11.234, 12.345, 13.456, 14.567, 15.678 };
double[] leftSubarray = { 10.123, 11.234, 12.345, 13.456, };
double[] midSubarray = { 11.234, 12.345, 13.456, 14.567, };
double[] rightSubarray = { 12.345, 13.456, 14.567, 15.678 };
assertTrue("0 start, mid end",
ArrayUtils.isEquals(leftSubarray,
ArrayUtils.subarray(array, 0, 4)));
assertTrue("0 start, length end",
ArrayUtils.isEquals(array,
ArrayUtils.subarray(array, 0, array.length)));
assertTrue("mid start, mid end",
ArrayUtils.isEquals(midSubarray,
ArrayUtils.subarray(array, 1, 5)));
assertTrue("mid start, length end",
ArrayUtils.isEquals(rightSubarray,
ArrayUtils.subarray(array, 2, array.length)));
assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3));
assertEquals("empty array", ArrayUtils.EMPTY_DOUBLE_ARRAY,
ArrayUtils.subarray(ArrayUtils.EMPTY_DOUBLE_ARRAY, 1, 2));
assertEquals("start > end", ArrayUtils.EMPTY_DOUBLE_ARRAY,
ArrayUtils.subarray(array, 4, 2));
assertEquals("start == end", ArrayUtils.EMPTY_DOUBLE_ARRAY,
ArrayUtils.subarray(array, 3, 3));
assertTrue("start undershoot, normal end",
ArrayUtils.isEquals(leftSubarray,
ArrayUtils.subarray(array, -2, 4)));
assertEquals("start overshoot, any end",
ArrayUtils.EMPTY_DOUBLE_ARRAY,
ArrayUtils.subarray(array, 33, 4));
assertTrue("normal start, end overshoot",
ArrayUtils.isEquals(rightSubarray,
ArrayUtils.subarray(array, 2, 33)));
assertTrue("start undershoot, end overshoot",
ArrayUtils.isEquals(array,
ArrayUtils.subarray(array, -2, 12)));
// empty-return tests
assertSame("empty array, object test",
ArrayUtils.EMPTY_DOUBLE_ARRAY,
ArrayUtils.subarray(ArrayUtils.EMPTY_DOUBLE_ARRAY, 1, 2));
assertSame("start > end, object test",
ArrayUtils.EMPTY_DOUBLE_ARRAY,
ArrayUtils.subarray(array, 4, 1));
assertSame("start == end, object test",
ArrayUtils.EMPTY_DOUBLE_ARRAY,
ArrayUtils.subarray(array, 3, 3));
assertSame("start overshoot, any end, object test",
ArrayUtils.EMPTY_DOUBLE_ARRAY,
ArrayUtils.subarray(array, 8733, 4));
// array type tests
assertSame("double type", double.class,
ArrayUtils.subarray(array, 2, 4).getClass().getComponentType());
}
public void testSubarrayFloat() {
float[] nullArray = null;
float[] array = { 10, 11, 12, 13, 14, 15 };
float[] leftSubarray = { 10, 11, 12, 13 };
float[] midSubarray = { 11, 12, 13, 14 };
float[] rightSubarray = { 12, 13, 14, 15 };
assertTrue("0 start, mid end",
ArrayUtils.isEquals(leftSubarray,
ArrayUtils.subarray(array, 0, 4)));
assertTrue("0 start, length end",
ArrayUtils.isEquals(array,
ArrayUtils.subarray(array, 0, array.length)));
assertTrue("mid start, mid end",
ArrayUtils.isEquals(midSubarray,
ArrayUtils.subarray(array, 1, 5)));
assertTrue("mid start, length end",
ArrayUtils.isEquals(rightSubarray,
ArrayUtils.subarray(array, 2, array.length)));
assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3));
assertEquals("empty array", ArrayUtils.EMPTY_FLOAT_ARRAY,
ArrayUtils.subarray(ArrayUtils.EMPTY_FLOAT_ARRAY, 1, 2));
assertEquals("start > end", ArrayUtils.EMPTY_FLOAT_ARRAY,
ArrayUtils.subarray(array, 4, 2));
assertEquals("start == end", ArrayUtils.EMPTY_FLOAT_ARRAY,
ArrayUtils.subarray(array, 3, 3));
assertTrue("start undershoot, normal end",
ArrayUtils.isEquals(leftSubarray,
ArrayUtils.subarray(array, -2, 4)));
assertEquals("start overshoot, any end",
ArrayUtils.EMPTY_FLOAT_ARRAY,
ArrayUtils.subarray(array, 33, 4));
assertTrue("normal start, end overshoot",
ArrayUtils.isEquals(rightSubarray,
ArrayUtils.subarray(array, 2, 33)));
assertTrue("start undershoot, end overshoot",
ArrayUtils.isEquals(array,
ArrayUtils.subarray(array, -2, 12)));
// empty-return tests
assertSame("empty array, object test",
ArrayUtils.EMPTY_FLOAT_ARRAY,
ArrayUtils.subarray(ArrayUtils.EMPTY_FLOAT_ARRAY, 1, 2));
assertSame("start > end, object test",
ArrayUtils.EMPTY_FLOAT_ARRAY,
ArrayUtils.subarray(array, 4, 1));
assertSame("start == end, object test",
ArrayUtils.EMPTY_FLOAT_ARRAY,
ArrayUtils.subarray(array, 3, 3));
assertSame("start overshoot, any end, object test",
ArrayUtils.EMPTY_FLOAT_ARRAY,
ArrayUtils.subarray(array, 8733, 4));
// array type tests
assertSame("float type", float.class,
ArrayUtils.subarray(array, 2, 4).getClass().getComponentType());
}
public void testSubarrayBoolean() {
boolean[] nullArray = null;
boolean[] array = { true, true, false, true, false, true };
boolean[] leftSubarray = { true, true, false, true };
boolean[] midSubarray = { true, false, true, false };
boolean[] rightSubarray = { false, true, false, true };
assertTrue("0 start, mid end",
ArrayUtils.isEquals(leftSubarray,
ArrayUtils.subarray(array, 0, 4)));
assertTrue("0 start, length end",
ArrayUtils.isEquals(array,
ArrayUtils.subarray(array, 0, array.length)));
assertTrue("mid start, mid end",
ArrayUtils.isEquals(midSubarray,
ArrayUtils.subarray(array, 1, 5)));
assertTrue("mid start, length end",
ArrayUtils.isEquals(rightSubarray,
ArrayUtils.subarray(array, 2, array.length)));
assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3));
assertEquals("empty array", ArrayUtils.EMPTY_BOOLEAN_ARRAY,
ArrayUtils.subarray(ArrayUtils.EMPTY_BOOLEAN_ARRAY, 1, 2));
assertEquals("start > end", ArrayUtils.EMPTY_BOOLEAN_ARRAY,
ArrayUtils.subarray(array, 4, 2));
assertEquals("start == end", ArrayUtils.EMPTY_BOOLEAN_ARRAY,
ArrayUtils.subarray(array, 3, 3));
assertTrue("start undershoot, normal end",
ArrayUtils.isEquals(leftSubarray,
ArrayUtils.subarray(array, -2, 4)));
assertEquals("start overshoot, any end",
ArrayUtils.EMPTY_BOOLEAN_ARRAY,
ArrayUtils.subarray(array, 33, 4));
assertTrue("normal start, end overshoot",
ArrayUtils.isEquals(rightSubarray,
ArrayUtils.subarray(array, 2, 33)));
assertTrue("start undershoot, end overshoot",
ArrayUtils.isEquals(array,
ArrayUtils.subarray(array, -2, 12)));
// empty-return tests
assertSame("empty array, object test",
ArrayUtils.EMPTY_BOOLEAN_ARRAY,
ArrayUtils.subarray(ArrayUtils.EMPTY_BOOLEAN_ARRAY, 1, 2));
assertSame("start > end, object test",
ArrayUtils.EMPTY_BOOLEAN_ARRAY,
ArrayUtils.subarray(array, 4, 1));
assertSame("start == end, object test",
ArrayUtils.EMPTY_BOOLEAN_ARRAY,
ArrayUtils.subarray(array, 3, 3));
assertSame("start overshoot, any end, object test",
ArrayUtils.EMPTY_BOOLEAN_ARRAY,
ArrayUtils.subarray(array, 8733, 4));
// array type tests
assertSame("boolean type", boolean.class,
ArrayUtils.subarray(array, 2, 4).getClass().getComponentType());
}
//-----------------------------------------------------------------------
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]));
}
//-----------------------------------------------------------------------
public void testReverse() {
StringBuffer str1 = new StringBuffer("pick");
String str2 = "a";
String[] str3 = new String[] {"stick"};
String str4 = "up";
Object[] array = new Object[] {str1, str2, str3};
ArrayUtils.reverse(array);
assertEquals(array[0], str3);
assertEquals(array[1], str2);
assertEquals(array[2], str1);
array = new Object[] {str1, str2, str3, str4};
ArrayUtils.reverse(array);
assertEquals(array[0], str4);
assertEquals(array[1], str3);
assertEquals(array[2], str2);
assertEquals(array[3], str1);
array = null;
ArrayUtils.reverse(array);
assertEquals(null, array);
}
public void testReverseLong() {
long[] array = new long[] {1L, 2L, 3L};
ArrayUtils.reverse(array);
assertEquals(array[0], 3L);
assertEquals(array[1], 2L);
assertEquals(array[2], 1L);
array = null;
ArrayUtils.reverse(array);
assertEquals(null, array);
}
public void testReverseInt() {
int[] array = new int[] {1, 2, 3};
ArrayUtils.reverse(array);
assertEquals(array[0], 3);
assertEquals(array[1], 2);
assertEquals(array[2], 1);
array = null;
ArrayUtils.reverse(array);
assertEquals(null, array);
}
public void testReverseShort() {
short[] array = new short[] {1, 2, 3};
ArrayUtils.reverse(array);
assertEquals(array[0], 3);
assertEquals(array[1], 2);
assertEquals(array[2], 1);
array = null;
ArrayUtils.reverse(array);
assertEquals(null, array);
}
public void testReverseChar() {
char[] array = new char[] {'a', 'f', 'C'};
ArrayUtils.reverse(array);
assertEquals(array[0], 'C');
assertEquals(array[1], 'f');
assertEquals(array[2], 'a');
array = null;
ArrayUtils.reverse(array);
assertEquals(null, array);
}
public void testReverseByte() {
byte[] array = new byte[] {2, 3, 4};
ArrayUtils.reverse(array);
assertEquals(array[0], 4);
assertEquals(array[1], 3);
assertEquals(array[2], 2);
array = null;
ArrayUtils.reverse(array);
assertEquals(null, array);
}
public void testReverseDouble() {
double[] array = new double[] {0.3d, 0.4d, 0.5d};
ArrayUtils.reverse(array);
assertEquals(array[0], 0.5d, 0.0d);
assertEquals(array[1], 0.4d, 0.0d);
assertEquals(array[2], 0.3d, 0.0d);
array = null;
ArrayUtils.reverse(array);
assertEquals(null, array);
}
public void testReverseFloat() {
float[] array = new float[] {0.3f, 0.4f, 0.5f};
ArrayUtils.reverse(array);
assertEquals(array[0], 0.5f, 0.0f);
assertEquals(array[1], 0.4f, 0.0f);
assertEquals(array[2], 0.3f, 0.0f);
array = null;
ArrayUtils.reverse(array);
assertEquals(null, array);
}
public void testReverseBoolean() {
boolean[] array = new boolean[] {false, false, true};
ArrayUtils.reverse(array);
assertEquals(array[0], true);
assertEquals(array[1], false);
assertEquals(array[2], false);
array = null;
ArrayUtils.reverse(array);
assertEquals(null, array);
}
//-----------------------------------------------------------------------
public void testIndexOf() {
Object[] array = new Object[] { "0", "1", "2", "3", null, "0" };
assertEquals(-1, ArrayUtils.indexOf(null, null));
assertEquals(-1, ArrayUtils.indexOf(null, "0"));
assertEquals(-1, ArrayUtils.indexOf(new Object[0], "0"));
assertEquals(0, ArrayUtils.indexOf(array, "0"));
assertEquals(1, ArrayUtils.indexOf(array, "1"));
assertEquals(2, ArrayUtils.indexOf(array, "2"));
assertEquals(3, ArrayUtils.indexOf(array, "3"));
assertEquals(4, ArrayUtils.indexOf(array, null));
assertEquals(-1, ArrayUtils.indexOf(array, "notInArray"));
}
public void testIndexOfWithStartIndex() {
Object[] array = new Object[] { "0", "1", "2", "3", null, "0" };
assertEquals(-1, ArrayUtils.indexOf(null, null, 2));
assertEquals(-1, ArrayUtils.indexOf(new Object[0], "0", 0));
assertEquals(-1, ArrayUtils.indexOf(null, "0", 2));
assertEquals(5, ArrayUtils.indexOf(array, "0", 2));
assertEquals(-1, ArrayUtils.indexOf(array, "1", 2));
assertEquals(2, ArrayUtils.indexOf(array, "2", 2));
assertEquals(3, ArrayUtils.indexOf(array, "3", 2));
assertEquals(4, ArrayUtils.indexOf(array, null, 2));
assertEquals(-1, ArrayUtils.indexOf(array, "notInArray", 2));
assertEquals(4, ArrayUtils.indexOf(array, null, -1));
assertEquals(-1, ArrayUtils.indexOf(array, null, 8));
assertEquals(-1, ArrayUtils.indexOf(array, "0", 8));
}
public void testLastIndexOf() {
Object[] array = new Object[] { "0", "1", "2", "3", null, "0" };
assertEquals(-1, ArrayUtils.lastIndexOf(null, null));
assertEquals(-1, ArrayUtils.lastIndexOf(null, "0"));
assertEquals(5, ArrayUtils.lastIndexOf(array, "0"));
assertEquals(1, ArrayUtils.lastIndexOf(array, "1"));
assertEquals(2, ArrayUtils.lastIndexOf(array, "2"));
assertEquals(3, ArrayUtils.lastIndexOf(array, "3"));
assertEquals(4, ArrayUtils.lastIndexOf(array, null));
assertEquals(-1, ArrayUtils.lastIndexOf(array, "notInArray"));
}
public void testLastIndexOfWithStartIndex() {
Object[] array = new Object[] { "0", "1", "2", "3", null, "0" };
assertEquals(-1, ArrayUtils.lastIndexOf(null, null, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(null, "0", 2));
assertEquals(0, ArrayUtils.lastIndexOf(array, "0", 2));
assertEquals(1, ArrayUtils.lastIndexOf(array, "1", 2));
assertEquals(2, ArrayUtils.lastIndexOf(array, "2", 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, "3", 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, "3", -1));
assertEquals(4, ArrayUtils.lastIndexOf(array, null, 5));
assertEquals(-1, ArrayUtils.lastIndexOf(array, null, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, "notInArray", 5));
assertEquals(-1, ArrayUtils.lastIndexOf(array, null, -1));
assertEquals(5, ArrayUtils.lastIndexOf(array, "0", 88));
}
public void testContains() {
Object[] array = new Object[] { "0", "1", "2", "3", null, "0" };
assertEquals(false, ArrayUtils.contains(null, null));
assertEquals(false, ArrayUtils.contains(null, "1"));
assertEquals(true, ArrayUtils.contains(array, "0"));
assertEquals(true, ArrayUtils.contains(array, "1"));
assertEquals(true, ArrayUtils.contains(array, "2"));
assertEquals(true, ArrayUtils.contains(array, "3"));
assertEquals(true, ArrayUtils.contains(array, null));
assertEquals(false, ArrayUtils.contains(array, "notInArray"));
}
//-----------------------------------------------------------------------
public void testIndexOfLong() {
long[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, 0));
array = new long[] { 0, 1, 2, 3, 0 };
assertEquals(0, ArrayUtils.indexOf(array, 0));
assertEquals(1, ArrayUtils.indexOf(array, 1));
assertEquals(2, ArrayUtils.indexOf(array, 2));
assertEquals(3, ArrayUtils.indexOf(array, 3));
assertEquals(-1, ArrayUtils.indexOf(array, 99));
}
public void testIndexOfLongWithStartIndex() {
long[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, 0, 2));
array = new long[] { 0, 1, 2, 3, 0 };
assertEquals(4, ArrayUtils.indexOf(array, 0, 2));
assertEquals(-1, ArrayUtils.indexOf(array, 1, 2));
assertEquals(2, ArrayUtils.indexOf(array, 2, 2));
assertEquals(3, ArrayUtils.indexOf(array, 3, 2));
assertEquals(3, ArrayUtils.indexOf(array, 3, -1));
assertEquals(-1, ArrayUtils.indexOf(array, 99, 0));
assertEquals(-1, ArrayUtils.indexOf(array, 0, 6));
}
public void testLastIndexOfLong() {
long[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, 0));
array = new long[] { 0, 1, 2, 3, 0 };
assertEquals(4, ArrayUtils.lastIndexOf(array, 0));
assertEquals(1, ArrayUtils.lastIndexOf(array, 1));
assertEquals(2, ArrayUtils.lastIndexOf(array, 2));
assertEquals(3, ArrayUtils.lastIndexOf(array, 3));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 99));
}
public void testLastIndexOfLongWithStartIndex() {
long[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2));
array = new long[] { 0, 1, 2, 3, 0 };
assertEquals(0, ArrayUtils.lastIndexOf(array, 0, 2));
assertEquals(1, ArrayUtils.lastIndexOf(array, 1, 2));
assertEquals(2, ArrayUtils.lastIndexOf(array, 2, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, -1));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 99, 4));
assertEquals(4, ArrayUtils.lastIndexOf(array, 0, 88));
}
public void testContainsLong() {
long[] array = null;
assertEquals(false, ArrayUtils.contains(array, 1));
array = new long[] { 0, 1, 2, 3, 0 };
assertEquals(true, ArrayUtils.contains(array, 0));
assertEquals(true, ArrayUtils.contains(array, 1));
assertEquals(true, ArrayUtils.contains(array, 2));
assertEquals(true, ArrayUtils.contains(array, 3));
assertEquals(false, ArrayUtils.contains(array, 99));
}
//-----------------------------------------------------------------------
public void testIndexOfInt() {
int[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, 0));
array = new int[] { 0, 1, 2, 3, 0 };
assertEquals(0, ArrayUtils.indexOf(array, 0));
assertEquals(1, ArrayUtils.indexOf(array, 1));
assertEquals(2, ArrayUtils.indexOf(array, 2));
assertEquals(3, ArrayUtils.indexOf(array, 3));
assertEquals(-1, ArrayUtils.indexOf(array, 99));
}
public void testIndexOfIntWithStartIndex() {
int[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, 0, 2));
array = new int[] { 0, 1, 2, 3, 0 };
assertEquals(4, ArrayUtils.indexOf(array, 0, 2));
assertEquals(-1, ArrayUtils.indexOf(array, 1, 2));
assertEquals(2, ArrayUtils.indexOf(array, 2, 2));
assertEquals(3, ArrayUtils.indexOf(array, 3, 2));
assertEquals(3, ArrayUtils.indexOf(array, 3, -1));
assertEquals(-1, ArrayUtils.indexOf(array, 99, 0));
assertEquals(-1, ArrayUtils.indexOf(array, 0, 6));
}
public void testLastIndexOfInt() {
int[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, 0));
array = new int[] { 0, 1, 2, 3, 0 };
assertEquals(4, ArrayUtils.lastIndexOf(array, 0));
assertEquals(1, ArrayUtils.lastIndexOf(array, 1));
assertEquals(2, ArrayUtils.lastIndexOf(array, 2));
assertEquals(3, ArrayUtils.lastIndexOf(array, 3));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 99));
}
public void testLastIndexOfIntWithStartIndex() {
int[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2));
array = new int[] { 0, 1, 2, 3, 0 };
assertEquals(0, ArrayUtils.lastIndexOf(array, 0, 2));
assertEquals(1, ArrayUtils.lastIndexOf(array, 1, 2));
assertEquals(2, ArrayUtils.lastIndexOf(array, 2, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, -1));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 99));
assertEquals(4, ArrayUtils.lastIndexOf(array, 0, 88));
}
public void testContainsInt() {
int[] array = null;
assertEquals(false, ArrayUtils.contains(array, 1));
array = new int[] { 0, 1, 2, 3, 0 };
assertEquals(true, ArrayUtils.contains(array, 0));
assertEquals(true, ArrayUtils.contains(array, 1));
assertEquals(true, ArrayUtils.contains(array, 2));
assertEquals(true, ArrayUtils.contains(array, 3));
assertEquals(false, ArrayUtils.contains(array, 99));
}
//-----------------------------------------------------------------------
public void testIndexOfShort() {
short[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, (short) 0));
array = new short[] { 0, 1, 2, 3, 0 };
assertEquals(0, ArrayUtils.indexOf(array, (short) 0));
assertEquals(1, ArrayUtils.indexOf(array, (short) 1));
assertEquals(2, ArrayUtils.indexOf(array, (short) 2));
assertEquals(3, ArrayUtils.indexOf(array, (short) 3));
assertEquals(-1, ArrayUtils.indexOf(array, (short) 99));
}
public void testIndexOfShortWithStartIndex() {
short[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, (short) 0, 2));
array = new short[] { 0, 1, 2, 3, 0 };
assertEquals(4, ArrayUtils.indexOf(array, (short) 0, 2));
assertEquals(-1, ArrayUtils.indexOf(array, (short) 1, 2));
assertEquals(2, ArrayUtils.indexOf(array, (short) 2, 2));
assertEquals(3, ArrayUtils.indexOf(array, (short) 3, 2));
assertEquals(3, ArrayUtils.indexOf(array, (short) 3, -1));
assertEquals(-1, ArrayUtils.indexOf(array, (short) 99, 0));
assertEquals(-1, ArrayUtils.indexOf(array, (short) 0, 6));
}
public void testLastIndexOfShort() {
short[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 0));
array = new short[] { 0, 1, 2, 3, 0 };
assertEquals(4, ArrayUtils.lastIndexOf(array, (short) 0));
assertEquals(1, ArrayUtils.lastIndexOf(array, (short) 1));
assertEquals(2, ArrayUtils.lastIndexOf(array, (short) 2));
assertEquals(3, ArrayUtils.lastIndexOf(array, (short) 3));
assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 99));
}
public void testLastIndexOfShortWithStartIndex() {
short[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 0, 2));
array = new short[] { 0, 1, 2, 3, 0 };
assertEquals(0, ArrayUtils.lastIndexOf(array, (short) 0, 2));
assertEquals(1, ArrayUtils.lastIndexOf(array, (short) 1, 2));
assertEquals(2, ArrayUtils.lastIndexOf(array, (short) 2, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 3, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 3, -1));
assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 99));
assertEquals(4, ArrayUtils.lastIndexOf(array, (short) 0, 88));
}
public void testContainsShort() {
short[] array = null;
assertEquals(false, ArrayUtils.contains(array, (short) 1));
array = new short[] { 0, 1, 2, 3, 0 };
assertEquals(true, ArrayUtils.contains(array, (short) 0));
assertEquals(true, ArrayUtils.contains(array, (short) 1));
assertEquals(true, ArrayUtils.contains(array, (short) 2));
assertEquals(true, ArrayUtils.contains(array, (short) 3));
assertEquals(false, ArrayUtils.contains(array, (short) 99));
}
//-----------------------------------------------------------------------
public void testIndexOfChar() {
char[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, 'a'));
array = new char[] { 'a', 'b', 'c', 'd', 'a' };
assertEquals(0, ArrayUtils.indexOf(array, 'a'));
assertEquals(1, ArrayUtils.indexOf(array, 'b'));
assertEquals(2, ArrayUtils.indexOf(array, 'c'));
assertEquals(3, ArrayUtils.indexOf(array, 'd'));
assertEquals(-1, ArrayUtils.indexOf(array, 'e'));
}
public void testIndexOfCharWithStartIndex() {
char[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, 'a', 2));
array = new char[] { 'a', 'b', 'c', 'd', 'a' };
assertEquals(4, ArrayUtils.indexOf(array, 'a', 2));
assertEquals(-1, ArrayUtils.indexOf(array, 'b', 2));
assertEquals(2, ArrayUtils.indexOf(array, 'c', 2));
assertEquals(3, ArrayUtils.indexOf(array, 'd', 2));
assertEquals(3, ArrayUtils.indexOf(array, 'd', -1));
assertEquals(-1, ArrayUtils.indexOf(array, 'e', 0));
assertEquals(-1, ArrayUtils.indexOf(array, 'a', 6));
}
public void testLastIndexOfChar() {
char[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, 'a'));
array = new char[] { 'a', 'b', 'c', 'd', 'a' };
assertEquals(4, ArrayUtils.lastIndexOf(array, 'a'));
assertEquals(1, ArrayUtils.lastIndexOf(array, 'b'));
assertEquals(2, ArrayUtils.lastIndexOf(array, 'c'));
assertEquals(3, ArrayUtils.lastIndexOf(array, 'd'));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 'e'));
}
public void testLastIndexOfCharWithStartIndex() {
char[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, 'a', 2));
array = new char[] { 'a', 'b', 'c', 'd', 'a' };
assertEquals(0, ArrayUtils.lastIndexOf(array, 'a', 2));
assertEquals(1, ArrayUtils.lastIndexOf(array, 'b', 2));
assertEquals(2, ArrayUtils.lastIndexOf(array, 'c', 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 'd', 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 'd', -1));
assertEquals(-1, ArrayUtils.lastIndexOf(array, 'e'));
assertEquals(4, ArrayUtils.lastIndexOf(array, 'a', 88));
}
public void testContainsChar() {
char[] array = null;
assertEquals(false, ArrayUtils.contains(array, 'b'));
array = new char[] { 'a', 'b', 'c', 'd', 'a' };
assertEquals(true, ArrayUtils.contains(array, 'a'));
assertEquals(true, ArrayUtils.contains(array, 'b'));
assertEquals(true, ArrayUtils.contains(array, 'c'));
assertEquals(true, ArrayUtils.contains(array, 'd'));
assertEquals(false, ArrayUtils.contains(array, 'e'));
}
//-----------------------------------------------------------------------
public void testIndexOfByte() {
byte[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, (byte) 0));
array = new byte[] { 0, 1, 2, 3, 0 };
assertEquals(0, ArrayUtils.indexOf(array, (byte) 0));
assertEquals(1, ArrayUtils.indexOf(array, (byte) 1));
assertEquals(2, ArrayUtils.indexOf(array, (byte) 2));
assertEquals(3, ArrayUtils.indexOf(array, (byte) 3));
assertEquals(-1, ArrayUtils.indexOf(array, (byte) 99));
}
public void testIndexOfByteWithStartIndex() {
byte[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, (byte) 0, 2));
array = new byte[] { 0, 1, 2, 3, 0 };
assertEquals(4, ArrayUtils.indexOf(array, (byte) 0, 2));
assertEquals(-1, ArrayUtils.indexOf(array, (byte) 1, 2));
assertEquals(2, ArrayUtils.indexOf(array, (byte) 2, 2));
assertEquals(3, ArrayUtils.indexOf(array, (byte) 3, 2));
assertEquals(3, ArrayUtils.indexOf(array, (byte) 3, -1));
assertEquals(-1, ArrayUtils.indexOf(array, (byte) 99, 0));
assertEquals(-1, ArrayUtils.indexOf(array, (byte) 0, 6));
}
public void testLastIndexOfByte() {
byte[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 0));
array = new byte[] { 0, 1, 2, 3, 0 };
assertEquals(4, ArrayUtils.lastIndexOf(array, (byte) 0));
assertEquals(1, ArrayUtils.lastIndexOf(array, (byte) 1));
assertEquals(2, ArrayUtils.lastIndexOf(array, (byte) 2));
assertEquals(3, ArrayUtils.lastIndexOf(array, (byte) 3));
assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 99));
}
public void testLastIndexOfByteWithStartIndex() {
byte[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 0, 2));
array = new byte[] { 0, 1, 2, 3, 0 };
assertEquals(0, ArrayUtils.lastIndexOf(array, (byte) 0, 2));
assertEquals(1, ArrayUtils.lastIndexOf(array, (byte) 1, 2));
assertEquals(2, ArrayUtils.lastIndexOf(array, (byte) 2, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 3, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 3, -1));
assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 99));
assertEquals(4, ArrayUtils.lastIndexOf(array, (byte) 0, 88));
}
public void testContainsByte() {
byte[] array = null;
assertEquals(false, ArrayUtils.contains(array, (byte) 1));
array = new byte[] { 0, 1, 2, 3, 0 };
assertEquals(true, ArrayUtils.contains(array, (byte) 0));
assertEquals(true, ArrayUtils.contains(array, (byte) 1));
assertEquals(true, ArrayUtils.contains(array, (byte) 2));
assertEquals(true, ArrayUtils.contains(array, (byte) 3));
assertEquals(false, ArrayUtils.contains(array, (byte) 99));
}
//-----------------------------------------------------------------------
public void testIndexOfDouble() {
double[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, (double) 0));
array = new double[0];
assertEquals(-1, ArrayUtils.indexOf(array, (double) 0));
array = new double[] { 0, 1, 2, 3, 0 };
assertEquals(0, ArrayUtils.indexOf(array, (double) 0));
assertEquals(1, ArrayUtils.indexOf(array, (double) 1));
assertEquals(2, ArrayUtils.indexOf(array, (double) 2));
assertEquals(3, ArrayUtils.indexOf(array, (double) 3));
assertEquals(3, ArrayUtils.indexOf(array, (double) 3, -1));
assertEquals(-1, ArrayUtils.indexOf(array, (double) 99));
}
public void testIndexOfDoubleTolerance() {
double[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, (double) 0));
array = new double[0];
assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, (double) 0));
array = new double[] { 0, 1, 2, 3, 0 };
assertEquals(0, ArrayUtils.indexOf(array, (double) 0, (double) 0.3));
assertEquals(2, ArrayUtils.indexOf(array, (double) 2.2, (double) 0.35));
assertEquals(3, ArrayUtils.indexOf(array, (double) 4.15, (double) 2.0));
assertEquals(1, ArrayUtils.indexOf(array, (double) 1.00001324, (double) 0.0001));
}
public void testIndexOfDoubleWithStartIndex() {
double[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, 2));
array = new double[0];
assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, 2));
array = new double[] { 0, 1, 2, 3, 0 };
assertEquals(4, ArrayUtils.indexOf(array, (double) 0, 2));
assertEquals(-1, ArrayUtils.indexOf(array, (double) 1, 2));
assertEquals(2, ArrayUtils.indexOf(array, (double) 2, 2));
assertEquals(3, ArrayUtils.indexOf(array, (double) 3, 2));
assertEquals(-1, ArrayUtils.indexOf(array, (double) 99, 0));
assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, 6));
}
public void testIndexOfDoubleWithStartIndexTolerance() {
double[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, 2, (double) 0));
array = new double[0];
assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, 2, (double) 0));
array = new double[] { 0, 1, 2, 3, 0 };
assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, 99, (double) 0.3));
assertEquals(0, ArrayUtils.indexOf(array, (double) 0, 0, (double) 0.3));
assertEquals(4, ArrayUtils.indexOf(array, (double) 0, 3, (double) 0.3));
assertEquals(2, ArrayUtils.indexOf(array, (double) 2.2, 0, (double) 0.35));
assertEquals(3, ArrayUtils.indexOf(array, (double) 4.15, 0, (double) 2.0));
assertEquals(1, ArrayUtils.indexOf(array, (double) 1.00001324, 0, (double) 0.0001));
assertEquals(3, ArrayUtils.indexOf(array, (double) 4.15, -1, (double) 2.0));
assertEquals(1, ArrayUtils.indexOf(array, (double) 1.00001324, -300, (double) 0.0001));
}
public void testLastIndexOfDouble() {
double[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0));
array = new double[0];
assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0));
array = new double[] { 0, 1, 2, 3, 0 };
assertEquals(4, ArrayUtils.lastIndexOf(array, (double) 0));
assertEquals(1, ArrayUtils.lastIndexOf(array, (double) 1));
assertEquals(2, ArrayUtils.lastIndexOf(array, (double) 2));
assertEquals(3, ArrayUtils.lastIndexOf(array, (double) 3));
assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 99));
}
public void testLastIndexOfDoubleTolerance() {
double[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0, (double) 0));
array = new double[0];
assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0, (double) 0));
array = new double[] { 0, 1, 2, 3, 0 };
assertEquals(4, ArrayUtils.lastIndexOf(array, (double) 0, (double) 0.3));
assertEquals(2, ArrayUtils.lastIndexOf(array, (double) 2.2, (double) 0.35));
assertEquals(3, ArrayUtils.lastIndexOf(array, (double) 4.15, (double) 2.0));
assertEquals(1, ArrayUtils.lastIndexOf(array, (double) 1.00001324, (double) 0.0001));
}
public void testLastIndexOfDoubleWithStartIndex() {
double[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0, 2));
array = new double[0];
assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0, 2));
array = new double[] { 0, 1, 2, 3, 0 };
assertEquals(0, ArrayUtils.lastIndexOf(array, (double) 0, 2));
assertEquals(1, ArrayUtils.lastIndexOf(array, (double) 1, 2));
assertEquals(2, ArrayUtils.lastIndexOf(array, (double) 2, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 3, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 3, -1));
assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 99));
assertEquals(4, ArrayUtils.lastIndexOf(array, (double) 0, 88));
}
public void testLastIndexOfDoubleWithStartIndexTolerance() {
double[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0, 2, (double) 0));
array = new double[0];
assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0, 2, (double) 0));
array = new double[] { (double) 3 };
assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 1, 0, (double) 0));
array = new double[] { 0, 1, 2, 3, 0 };
assertEquals(4, ArrayUtils.lastIndexOf(array, (double) 0, 99, (double) 0.3));
assertEquals(0, ArrayUtils.lastIndexOf(array, (double) 0, 3, (double) 0.3));
assertEquals(2, ArrayUtils.lastIndexOf(array, (double) 2.2, 3, (double) 0.35));
assertEquals(3, ArrayUtils.lastIndexOf(array, (double) 4.15, array.length, (double) 2.0));
assertEquals(1, ArrayUtils.lastIndexOf(array, (double) 1.00001324, array.length, (double) 0.0001));
assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 4.15, -200, (double) 2.0));
}
public void testContainsDouble() {
double[] array = null;
assertEquals(false, ArrayUtils.contains(array, (double) 1));
array = new double[] { 0, 1, 2, 3, 0 };
assertEquals(true, ArrayUtils.contains(array, (double) 0));
assertEquals(true, ArrayUtils.contains(array, (double) 1));
assertEquals(true, ArrayUtils.contains(array, (double) 2));
assertEquals(true, ArrayUtils.contains(array, (double) 3));
assertEquals(false, ArrayUtils.contains(array, (double) 99));
}
public void testContainsDoubleTolerance() {
double[] array = null;
assertEquals(false, ArrayUtils.contains(array, (double) 1, (double) 0));
array = new double[] { 0, 1, 2, 3, 0 };
assertEquals(false, ArrayUtils.contains(array, (double) 4.0, (double) 0.33));
assertEquals(false, ArrayUtils.contains(array, (double) 2.5, (double) 0.49));
assertEquals(true, ArrayUtils.contains(array, (double) 2.5, (double) 0.50));
assertEquals(true, ArrayUtils.contains(array, (double) 2.5, (double) 0.51));
}
//-----------------------------------------------------------------------
public void testIndexOfFloat() {
float[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, (float) 0));
array = new float[0];
assertEquals(-1, ArrayUtils.indexOf(array, (float) 0));
array = new float[] { 0, 1, 2, 3, 0 };
assertEquals(0, ArrayUtils.indexOf(array, (float) 0));
assertEquals(1, ArrayUtils.indexOf(array, (float) 1));
assertEquals(2, ArrayUtils.indexOf(array, (float) 2));
assertEquals(3, ArrayUtils.indexOf(array, (float) 3));
assertEquals(-1, ArrayUtils.indexOf(array, (float) 99));
}
public void testIndexOfFloatWithStartIndex() {
float[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, (float) 0, 2));
array = new float[0];
assertEquals(-1, ArrayUtils.indexOf(array, (float) 0, 2));
array = new float[] { 0, 1, 2, 3, 0 };
assertEquals(4, ArrayUtils.indexOf(array, (float) 0, 2));
assertEquals(-1, ArrayUtils.indexOf(array, (float) 1, 2));
assertEquals(2, ArrayUtils.indexOf(array, (float) 2, 2));
assertEquals(3, ArrayUtils.indexOf(array, (float) 3, 2));
assertEquals(3, ArrayUtils.indexOf(array, (float) 3, -1));
assertEquals(-1, ArrayUtils.indexOf(array, (float) 99, 0));
assertEquals(-1, ArrayUtils.indexOf(array, (float) 0, 6));
}
public void testLastIndexOfFloat() {
float[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, (float) 0));
array = new float[0];
assertEquals(-1, ArrayUtils.lastIndexOf(array, (float) 0));
array = new float[] { 0, 1, 2, 3, 0 };
assertEquals(4, ArrayUtils.lastIndexOf(array, (float) 0));
assertEquals(1, ArrayUtils.lastIndexOf(array, (float) 1));
assertEquals(2, ArrayUtils.lastIndexOf(array, (float) 2));
assertEquals(3, ArrayUtils.lastIndexOf(array, (float) 3));
assertEquals(-1, ArrayUtils.lastIndexOf(array, (float) 99));
}
public void testLastIndexOfFloatWithStartIndex() {
float[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, (float) 0, 2));
array = new float[0];
assertEquals(-1, ArrayUtils.lastIndexOf(array, (float) 0, 2));
array = new float[] { 0, 1, 2, 3, 0 };
assertEquals(0, ArrayUtils.lastIndexOf(array, (float) 0, 2));
assertEquals(1, ArrayUtils.lastIndexOf(array, (float) 1, 2));
assertEquals(2, ArrayUtils.lastIndexOf(array, (float) 2, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, (float) 3, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, (float) 3, -1));
assertEquals(-1, ArrayUtils.lastIndexOf(array, (float) 99));
assertEquals(4, ArrayUtils.lastIndexOf(array, (float) 0, 88));
}
public void testContainsFloat() {
float[] array = null;
assertEquals(false, ArrayUtils.contains(array, (float) 1));
array = new float[] { 0, 1, 2, 3, 0 };
assertEquals(true, ArrayUtils.contains(array, (float) 0));
assertEquals(true, ArrayUtils.contains(array, (float) 1));
assertEquals(true, ArrayUtils.contains(array, (float) 2));
assertEquals(true, ArrayUtils.contains(array, (float) 3));
assertEquals(false, ArrayUtils.contains(array, (float) 99));
}
//-----------------------------------------------------------------------
public void testIndexOfBoolean() {
boolean[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, true));
array = new boolean[0];
assertEquals(-1, ArrayUtils.indexOf(array, true));
array = new boolean[] { true, false, true };
assertEquals(0, ArrayUtils.indexOf(array, true));
assertEquals(1, ArrayUtils.indexOf(array, false));
array = new boolean[] { true, true };
assertEquals(-1, ArrayUtils.indexOf(array, false));
}
public void testIndexOfBooleanWithStartIndex() {
boolean[] array = null;
assertEquals(-1, ArrayUtils.indexOf(array, true, 2));
array = new boolean[0];
assertEquals(-1, ArrayUtils.indexOf(array, true, 2));
array = new boolean[] { true, false, true };
assertEquals(2, ArrayUtils.indexOf(array, true, 1));
assertEquals(-1, ArrayUtils.indexOf(array, false, 2));
assertEquals(1, ArrayUtils.indexOf(array, false, 0));
assertEquals(1, ArrayUtils.indexOf(array, false, -1));
array = new boolean[] { true, true };
assertEquals(-1, ArrayUtils.indexOf(array, false, 0));
assertEquals(-1, ArrayUtils.indexOf(array, false, -1));
}
public void testLastIndexOfBoolean() {
boolean[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, true));
array = new boolean[0];
assertEquals(-1, ArrayUtils.lastIndexOf(array, true));
array = new boolean[] { true, false, true };
assertEquals(2, ArrayUtils.lastIndexOf(array, true));
assertEquals(1, ArrayUtils.lastIndexOf(array, false));
array = new boolean[] { true, true };
assertEquals(-1, ArrayUtils.lastIndexOf(array, false));
}
public void testLastIndexOfBooleanWithStartIndex() {
boolean[] array = null;
assertEquals(-1, ArrayUtils.lastIndexOf(array, true, 2));
array = new boolean[0];
assertEquals(-1, ArrayUtils.lastIndexOf(array, true, 2));
array = new boolean[] { true, false, true };
assertEquals(2, ArrayUtils.lastIndexOf(array, true, 2));
assertEquals(0, ArrayUtils.lastIndexOf(array, true, 1));
assertEquals(1, ArrayUtils.lastIndexOf(array, false, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, true, -1));
array = new boolean[] { true, true };
assertEquals(-1, ArrayUtils.lastIndexOf(array, false, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(array, true, -1));
}
public void testContainsBoolean() {
boolean[] array = null;
assertEquals(false, ArrayUtils.contains(array, true));
array = new boolean[] { true, false, true };
assertEquals(true, ArrayUtils.contains(array, true));
assertEquals(true, ArrayUtils.contains(array, false));
array = new boolean[] { true, true };
assertEquals(true, ArrayUtils.contains(array, true));
assertEquals(false, ArrayUtils.contains(array, false));
}
// testToPrimitive/Object for boolean
// -----------------------------------------------------------------------
public void testToPrimitive_boolean() {
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},
ArrayUtils.toPrimitive(new Boolean[] {Boolean.TRUE, Boolean.FALSE, Boolean.TRUE}))
);
try {
ArrayUtils.toPrimitive(new Boolean[] {Boolean.TRUE, null});
fail();
} catch (NullPointerException ex) {}
}
public void testToPrimitive_boolean_boolean() {
assertEquals(null, ArrayUtils.toPrimitive(null, false));
assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.toPrimitive(new Boolean[0], false));
assertTrue(Arrays.equals(
new boolean[] {true, false, true},
ArrayUtils.toPrimitive(new Boolean[] {Boolean.TRUE, Boolean.FALSE, Boolean.TRUE}, false))
);
assertTrue(Arrays.equals(
new boolean[] {true, false, false},
ArrayUtils.toPrimitive(new Boolean[] {Boolean.TRUE, null, Boolean.FALSE}, false))
);
assertTrue(Arrays.equals(
new boolean[] {true, true, false},
ArrayUtils.toPrimitive(new Boolean[] {Boolean.TRUE, null, Boolean.FALSE}, true))
);
}
public void testToObject_boolean() {
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_char() {
final Character[] b = null;
assertEquals(null, ArrayUtils.toPrimitive(b));
assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.toPrimitive(new Character[0]));
assertTrue(Arrays.equals(
new char[] {Character.MIN_VALUE, Character.MAX_VALUE, '0'},
ArrayUtils.toPrimitive(new Character[] {new Character(Character.MIN_VALUE),
new Character(Character.MAX_VALUE), new Character('0')}))
);
try {
ArrayUtils.toPrimitive(new Character[] {new Character(Character.MIN_VALUE), null});
fail();
} catch (NullPointerException ex) {}
}
public void testToPrimitive_char_char() {
final Character[] b = null;
assertEquals(null, ArrayUtils.toPrimitive(b, Character.MIN_VALUE));
assertSame(ArrayUtils.EMPTY_CHAR_ARRAY,
ArrayUtils.toPrimitive(new Character[0], (char)0));
assertTrue(Arrays.equals(
new char[] {Character.MIN_VALUE, Character.MAX_VALUE, '0'},
ArrayUtils.toPrimitive(new Character[] {new Character(Character.MIN_VALUE),
new Character(Character.MAX_VALUE), new Character('0')},
Character.MIN_VALUE))
);
assertTrue(Arrays.equals(
new char[] {Character.MIN_VALUE, Character.MAX_VALUE, '0'},
ArrayUtils.toPrimitive(new Character[] {new Character(Character.MIN_VALUE), null,
new Character('0')}, Character.MAX_VALUE))
);
}
public void testToObject_char() {
final char[] b = null;
assertEquals(null, ArrayUtils.toObject(b));
assertSame(ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY,
ArrayUtils.toObject(new char[0]));
assertTrue(Arrays.equals(
new Character[] {new Character(Character.MIN_VALUE),
new Character(Character.MAX_VALUE), new Character('0')},
ArrayUtils.toObject(new char[] {Character.MIN_VALUE, Character.MAX_VALUE,
'0'} ))
);
}
// 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 testToPrimitive_intNull() {
Integer[] iArray = null;
assertEquals(null, ArrayUtils.toPrimitive(iArray, Integer.MIN_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 })));
}
//-----------------------------------------------------------------------
/**
* Test for {@link ArrayUtils#isEmpty(java.lang.Object[])}.
*/
public void testIsEmptyObject() {
Object[] emptyArray = new Object[] {};
Object[] notEmptyArray = new Object[] { new String("Value") };
assertEquals(true, ArrayUtils.isEmpty((Object[])null));
assertEquals(true, ArrayUtils.isEmpty(emptyArray));
assertEquals(false, ArrayUtils.isEmpty(notEmptyArray));
}
/**
* Tests for {@link ArrayUtils#isEmpty(long[])},
* {@link ArrayUtils#isEmpty(int[])},
* {@link ArrayUtils#isEmpty(short[])},
* {@link ArrayUtils#isEmpty(char[])},
* {@link ArrayUtils#isEmpty(byte[])},
* {@link ArrayUtils#isEmpty(double[])},
* {@link ArrayUtils#isEmpty(float[])} and
* {@link ArrayUtils#isEmpty(boolean[])}.
*/
public void testIsEmptyPrimitives() {
long[] emptyLongArray = new long[] {};
long[] notEmptyLongArray = new long[] { 1L };
assertEquals(true, ArrayUtils.isEmpty((long[])null));
assertEquals(true, ArrayUtils.isEmpty(emptyLongArray));
assertEquals(false, ArrayUtils.isEmpty(notEmptyLongArray));
int[] emptyIntArray = new int[] {};
int[] notEmptyIntArray = new int[] { 1 };
assertEquals(true, ArrayUtils.isEmpty((int[])null));
assertEquals(true, ArrayUtils.isEmpty(emptyIntArray));
assertEquals(false, ArrayUtils.isEmpty(notEmptyIntArray));
short[] emptyShortArray = new short[] {};
short[] notEmptyShortArray = new short[] { 1 };
assertEquals(true, ArrayUtils.isEmpty((short[])null));
assertEquals(true, ArrayUtils.isEmpty(emptyShortArray));
assertEquals(false, ArrayUtils.isEmpty(notEmptyShortArray));
char[] emptyCharArray = new char[] {};
char[] notEmptyCharArray = new char[] { 1 };
assertEquals(true, ArrayUtils.isEmpty((char[])null));
assertEquals(true, ArrayUtils.isEmpty(emptyCharArray));
assertEquals(false, ArrayUtils.isEmpty(notEmptyCharArray));
byte[] emptyByteArray = new byte[] {};
byte[] notEmptyByteArray = new byte[] { 1 };
assertEquals(true, ArrayUtils.isEmpty((byte[])null));
assertEquals(true, ArrayUtils.isEmpty(emptyByteArray));
assertEquals(false, ArrayUtils.isEmpty(notEmptyByteArray));
double[] emptyDoubleArray = new double[] {};
double[] notEmptyDoubleArray = new double[] { 1.0 };
assertEquals(true, ArrayUtils.isEmpty((double[])null));
assertEquals(true, ArrayUtils.isEmpty(emptyDoubleArray));
assertEquals(false, ArrayUtils.isEmpty(notEmptyDoubleArray));
float[] emptyFloatArray = new float[] {};
float[] notEmptyFloatArray = new float[] { 1.0F };
assertEquals(true, ArrayUtils.isEmpty((float[])null));
assertEquals(true, ArrayUtils.isEmpty(emptyFloatArray));
assertEquals(false, ArrayUtils.isEmpty(notEmptyFloatArray));
boolean[] emptyBooleanArray = new boolean[] {};
boolean[] notEmptyBooleanArray = new boolean[] { true };
assertEquals(true, ArrayUtils.isEmpty((boolean[])null));
assertEquals(true, ArrayUtils.isEmpty(emptyBooleanArray));
assertEquals(false, ArrayUtils.isEmpty(notEmptyBooleanArray));
}
// ------------------------------------------------------------------------
public void testGetLength() {
assertEquals(0, ArrayUtils.getLength(null));
Object[] emptyObjectArray = new Object[0];
Object[] notEmptyObjectArray = new Object[] {"aValue"};
assertEquals(0, ArrayUtils.getLength((Object[]) null));
assertEquals(0, ArrayUtils.getLength(emptyObjectArray));
assertEquals(1, ArrayUtils.getLength(notEmptyObjectArray));
int[] emptyIntArray = new int[] {};
int[] notEmptyIntArray = new int[] { 1 };
assertEquals(0, ArrayUtils.getLength((int[]) null));
assertEquals(0, ArrayUtils.getLength(emptyIntArray));
assertEquals(1, ArrayUtils.getLength(notEmptyIntArray));
short[] emptyShortArray = new short[] {};
short[] notEmptyShortArray = new short[] { 1 };
assertEquals(0, ArrayUtils.getLength((short[]) null));
assertEquals(0, ArrayUtils.getLength(emptyShortArray));
assertEquals(1, ArrayUtils.getLength(notEmptyShortArray));
char[] emptyCharArray = new char[] {};
char[] notEmptyCharArray = new char[] { 1 };
assertEquals(0, ArrayUtils.getLength((char[]) null));
assertEquals(0, ArrayUtils.getLength(emptyCharArray));
assertEquals(1, ArrayUtils.getLength(notEmptyCharArray));
byte[] emptyByteArray = new byte[] {};
byte[] notEmptyByteArray = new byte[] { 1 };
assertEquals(0, ArrayUtils.getLength((byte[]) null));
assertEquals(0, ArrayUtils.getLength(emptyByteArray));
assertEquals(1, ArrayUtils.getLength(notEmptyByteArray));
double[] emptyDoubleArray = new double[] {};
double[] notEmptyDoubleArray = new double[] { 1.0 };
assertEquals(0, ArrayUtils.getLength((double[]) null));
assertEquals(0, ArrayUtils.getLength(emptyDoubleArray));
assertEquals(1, ArrayUtils.getLength(notEmptyDoubleArray));
float[] emptyFloatArray = new float[] {};
float[] notEmptyFloatArray = new float[] { 1.0F };
assertEquals(0, ArrayUtils.getLength((float[]) null));
assertEquals(0, ArrayUtils.getLength(emptyFloatArray));
assertEquals(1, ArrayUtils.getLength(notEmptyFloatArray));
boolean[] emptyBooleanArray = new boolean[] {};
boolean[] notEmptyBooleanArray = new boolean[] { true };
assertEquals(0, ArrayUtils.getLength((boolean[]) null));
assertEquals(0, ArrayUtils.getLength(emptyBooleanArray));
assertEquals(1, ArrayUtils.getLength(notEmptyBooleanArray));
try {
ArrayUtils.getLength("notAnArray");
fail("IllegalArgumentException should have been thrown");
} catch (IllegalArgumentException e) {}
}
}