jpa/tests/org.eclipse.jpt.utility.tests/src/org/eclipse/jpt/utility/tests/internal/ArrayToolsTests.java

/*******************************************************************************
 * Copyright (c) 2005, 2010 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0, which accompanies this distribution
 * and is available at http://www.eclipse.org/legal/epl-v10.html.
 * 
 * Contributors:
 *     Oracle - initial API and implementation
 ******************************************************************************/
package org.eclipse.jpt.utility.tests.internal;

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;

import junit.framework.TestCase;

import org.eclipse.jpt.utility.internal.ArrayTools;
import org.eclipse.jpt.utility.internal.ReflectionTools;
import org.eclipse.jpt.utility.internal.Range;
import org.eclipse.jpt.utility.internal.ReverseComparator;
import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;

@SuppressWarnings("nls")
public class ArrayToolsTests extends TestCase {

	public ArrayToolsTests(String name) {
		super(name);
	}


	// ********** instantiation **********

	public void testNewArrayObjectArrayInt() {
		String[] array1 = new String[2];
		String[] array2 = ArrayTools.newArray(array1, 5);
		array2[0] = "foo";
		array2[4] = "bar";
		assertEquals(String.class, array2.getClass().getComponentType());
		assertEquals(5, array2.length);
	}

	public void testNewArrayObjectArrayInt_Exception() {
		String[] array1 = new String[2];
		Object[] array2 = ArrayTools.newArray(array1, 5);
		boolean exCaught = false;
		try {
			array2[1] = Integer.valueOf(7);
			fail("bogus array: " + Arrays.toString(array2));
		} catch (ArrayStoreException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);
	}

	public void testComponentType() {
		String[] array = new String[2];
		Class<? extends String> javaClass = ArrayTools.componentType(array);
		assertEquals(String.class, javaClass);
	}

	public void testNewArrayClassInt() {
		String[] array = ArrayTools.newArray(String.class, 5);
		array[0] = "foo";
		array[4] = "bar";
		assertEquals(String.class, array.getClass().getComponentType());
		assertEquals(5, array.length);
	}

	public void testNewArrayClassInt_Exception() {
		Object[] array = ArrayTools.newArray(String.class, 5);
		boolean exCaught = false;
		try {
			array[1] = Integer.valueOf(7);
			fail("bogus array: " + Arrays.toString(array));
		} catch (ArrayStoreException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);
	}

	public void testNewArrayClassInt_Primitive() {
		boolean exCaught = false;
		try {
			Object[] array = ArrayTools.newArray(int.class, 5);
			fail("bogus array: " + Arrays.toString(array));
		} catch (IllegalArgumentException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);
	}


	// ********** conversion **********

	public void testArrayIterable() {
		Iterable<String> iterable = this.buildStringList1();
		Object[] a = ArrayTools.array(iterable);
		assertEquals(3, a.length);
		assertTrue(ArrayTools.containsAll(a, this.buildStringList1().iterator()));
	}

	public void testArrayIterableInt() {
		Iterable<String> iterable = this.buildStringList1();
		Object[] a = ArrayTools.array(iterable, 3);
		assertEquals(3, a.length);
		assertTrue(ArrayTools.containsAll(a, this.buildStringList1().iterator()));
	}

	public void testArrayIterableObjectArray_String() {
		Iterable<String> iterable = this.buildStringList1();
		String[] a = ArrayTools.array(iterable, new String[0]);
		assertEquals(3, a.length);
		assertTrue(ArrayTools.containsAll(a, this.buildStringList1().iterator()));
	}

	public void testArrayIterableObjectArray_Object() {
		Iterable<String> iterable = this.buildStringList1();
		Object[] a = ArrayTools.array(iterable, new Object[0]);
		assertEquals(3, a.length);
		assertTrue(ArrayTools.containsAll(a, this.buildStringList1().iterator()));
	}

	public void testArrayIterableIntObjectArray() {
		Iterable<String> iterable = this.buildStringList1();
		String[] a = ArrayTools.array(iterable, 3, new String[0]);
		assertEquals(3, a.length);
		assertTrue(ArrayTools.containsAll(a, this.buildStringList1().iterator()));
	}

	public void testArrayIterator() {
		Object[] a = ArrayTools.array(this.buildStringList1().iterator());
		assertEquals(3, a.length);
		assertTrue(ArrayTools.containsAll(a, this.buildStringList1().iterator()));
	}

	public void testArrayIterator_Empty() {
		Object[] a = ArrayTools.array(EmptyIterator.instance());
		assertEquals(0, a.length);
	}

	public void testArrayIteratorInt() {
		Object[] a = ArrayTools.array(this.buildStringList1().iterator(), 3);
		assertEquals(3, a.length);
		assertTrue(ArrayTools.containsAll(a, this.buildStringList1().iterator()));
	}

	public void testArrayIteratorInt_Empty() {
		Object[] a = ArrayTools.array(EmptyIterator.instance(), 3);
		assertEquals(0, a.length);
	}

	public void testArrayIteratorObjectArray_String() {
		String[] a = ArrayTools.array(this.buildStringList1().iterator(), new String[0]);
		assertEquals(3, a.length);
		assertTrue(ArrayTools.containsAll(a, this.buildStringList1().iterator()));
	}

	public void testArrayIteratorObjectArray_Empty() {
		String[] a = ArrayTools.array(EmptyIterator.<String>instance(), new String[0]);
		assertEquals(0, a.length);
	}

	public void testArrayIteratorObjectArray_Empty_ClearArray() {
		String[] a = ArrayTools.array(EmptyIterator.<String>instance(), new String[5]);
		assertEquals(5, a.length);
		assertNull(a[0]);
	}

	public void testArrayIteratorObjectArray_Object() {
		Object[] a = ArrayTools.array(this.buildStringList1().iterator(), new Object[0]);
		assertEquals(3, a.length);
		assertTrue(ArrayTools.containsAll(a, this.buildStringList1().iterator()));
	}

	public void testArrayIteratorIntObjectArray() {
		String[] a = ArrayTools.array(this.buildStringList1().iterator(), 3, new String[0]);
		assertEquals(3, a.length);
		assertTrue(ArrayTools.containsAll(a, this.buildStringList1().iterator()));
	}

	public void testArrayIteratorIntObjectArray_Empty() {
		String[] a = ArrayTools.array(EmptyIterator.<String>instance(), 3, new String[0]);
		assertEquals(0, a.length);
	}


	// ********** add **********

	public void testAddObjectArrayObject_Object() {
		Object[] a = ArrayTools.add(this.buildObjectArray1(), "twenty");
		assertEquals(4, a.length);
		assertTrue(ArrayTools.contains(a, "twenty"));
		assertEquals("twenty", a[a.length-1]);
	}

	public void testAddObjectArrayObject_String() {
		String[] a = ArrayTools.add(this.buildStringArray1(), "twenty");
		assertEquals(4, a.length);
		assertTrue(ArrayTools.contains(a, "twenty"));
		assertEquals("twenty", a[a.length-1]);
	}

	public void testAddObjectArrayObject_EmptyArray() {
		String[] a = new String[0];
		a = ArrayTools.add(a, "twenty");
		assertEquals(1, a.length);
		assertTrue(ArrayTools.contains(a, "twenty"));
		assertEquals("twenty", a[0]);
	}

	public void testAddObjectArrayIntObject_Object() {
		Object[] a = new Object[] { "a", "b", "c", "d" };
		a = ArrayTools.add(a, 2, "X");
		assertEquals(5, a.length);
		assertTrue(ArrayTools.contains(a, "X"));
		assertTrue(Arrays.equals(new Object[] { "a", "b", "X", "c", "d" }, a));
	}

	public void testAddObjectArrayIntObject_String() {
		String[] a = new String[] { "a", "b", "c", "d" };
		a = ArrayTools.add(a, 2, "X");
		assertEquals(5, a.length);
		assertTrue(ArrayTools.contains(a, "X"));
		assertTrue(Arrays.equals(new String[] { "a", "b", "X", "c", "d" }, a));
	}

	public void testAddObjectArrayIntObject_End() {
		String[] a = new String[] { "a", "b", "c", "d" };
		a = ArrayTools.add(a, 4, "X");
		assertEquals(5, a.length);
		assertTrue(ArrayTools.contains(a, "X"));
		assertTrue(Arrays.equals(new String[] { "a", "b", "c", "d", "X" }, a));
	}

	public void testAddObjectArrayIntObject_Zero() {
		String[] a = new String[] { "a", "b", "c", "d" };
		a = ArrayTools.add(a, 0, "X");
		assertEquals(5, a.length);
		assertTrue(ArrayTools.contains(a, "X"));
		assertTrue(Arrays.equals(new String[] { "X", "a", "b", "c", "d" }, a));
	}

	public void testAddObjectArrayIntObject_Exception() {
		Object[] a = new Object[] { "a", "b", "c", "d" };
		boolean exCaught = false;
		try {
			a = ArrayTools.add(a, 33, "X");
		} catch (IndexOutOfBoundsException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);
	}

	public void testAddCharArrayChar() {
		char[] a = ArrayTools.add(this.buildCharArray(), 'd');
		assertEquals(4, a.length);
		assertTrue(ArrayTools.contains(a, 'd'));
	}

	public void testAddCharArrayChar_Empty() {
		char[] a = new char[0];
		a = ArrayTools.add(a, 'd');
		assertEquals(1, a.length);
		assertTrue(ArrayTools.contains(a, 'd'));
		assertTrue(Arrays.equals(new char[] { 'd' }, a));
	}

	public void testAddCharArrayIntChar() {
		char[] a = new char[] { 'a', 'b', 'c', 'd' };
		a = ArrayTools.add(a, 2, 'X');
		assertEquals(5, a.length);
		assertTrue(ArrayTools.contains(a, 'X'));
		assertTrue(Arrays.equals(new char[] { 'a', 'b', 'X', 'c', 'd' }, a));
	}

	public void testAddCharArrayIntChar_Zero() {
		char[] a = new char[] { 'a', 'b', 'c', 'd' };
		a = ArrayTools.add(a, 0, 'X');
		assertEquals(5, a.length);
		assertTrue(ArrayTools.contains(a, 'X'));
		assertTrue(Arrays.equals(new char[] { 'X', 'a', 'b', 'c', 'd' }, a));
	}

	public void testAddCharArrayIntChar_End() {
		char[] a = new char[] { 'a', 'b', 'c', 'd' };
		a = ArrayTools.add(a, 4, 'X');
		assertEquals(5, a.length);
		assertTrue(ArrayTools.contains(a, 'X'));
		assertTrue(Arrays.equals(new char[] { 'a', 'b', 'c', 'd', 'X' }, a));
	}

	public void testAddIntArrayInt() {
		int[] a = ArrayTools.add(this.buildIntArray(), 30);
		assertEquals(4, a.length);
		assertTrue(ArrayTools.contains(a, 30));
	}

	public void testAddIntArrayInt_Empty() {
		int[] a = new int[0];
		a = ArrayTools.add(a, 30);
		assertEquals(1, a.length);
		assertTrue(ArrayTools.contains(a, 30));
		assertTrue(Arrays.equals(new int[] { 30 }, a));
	}

	public void testAddIntArrayIntInt() {
		int[] a = new int[] { 1, 2, 3, 4 };
		a = ArrayTools.add(a, 2, 99);
		assertEquals(5, a.length);
		assertTrue(ArrayTools.contains(a, 99));
		assertTrue(Arrays.equals(new int[] { 1, 2, 99, 3, 4 }, a));
	}

	public void testAddIntArrayIntInt_Zero() {
		int[] a = new int[] { 1, 2, 3, 4 };
		a = ArrayTools.add(a, 0, 99);
		assertEquals(5, a.length);
		assertTrue(ArrayTools.contains(a, 99));
		assertTrue(Arrays.equals(new int[] { 99, 1, 2, 3, 4 }, a));
	}

	public void testAddIntArrayIntInt_End() {
		int[] a = new int[] { 1, 2, 3, 4 };
		a = ArrayTools.add(a, 4, 99);
		assertEquals(5, a.length);
		assertTrue(ArrayTools.contains(a, 99));
		assertTrue(Arrays.equals(new int[] { 1, 2, 3, 4, 99 }, a));
	}


	// ********** add all **********

	public void testAddAllObjectArrayCollection_String() {
		String[] a = this.buildStringArray1();
		Collection<String> c = this.buildStringList2();
		String[] newArray = ArrayTools.addAll(a, c);

		assertEquals(6, newArray.length);
		assertTrue(ArrayTools.containsAll(newArray, c));
	}

	public void testAddAllObjectArrayCollection_Object() {
		Object[] a = this.buildObjectArray1();
		Collection<String> c = this.buildStringList2();
		Object[] newArray = ArrayTools.addAll(a, c);

		assertEquals(6, newArray.length);
		assertTrue(ArrayTools.containsAll(newArray, c));
	}

	public void testAddAllObjectArrayCollection_EmptyArray() {
		String[] a = new String[0];
		Collection<String> c = this.buildStringList2();
		String[] newArray = ArrayTools.addAll(a, c);

		assertEquals(3, newArray.length);
		assertTrue(ArrayTools.containsAll(newArray, c));
	}

	public void testAddAllObjectArrayCollection_EmptyCollection() {
		String[] a = this.buildStringArray1();
		Collection<String> c = new ArrayList<String>();
		String[] newArray = ArrayTools.addAll(a, c);

		assertEquals(3, newArray.length);
	}

	public void testAddAllObjectArrayIntCollection_String() {
		String[] a = this.buildStringArray1();
		Collection<String> c = this.buildStringList2();
		String[] newArray = ArrayTools.addAll(a, 1, c);

		assertEquals(6, newArray.length);
		assertTrue(ArrayTools.containsAll(newArray, c));
	}

	public void testAddAllObjectArrayIntCollection_String_End() {
		String[] a = this.buildStringArray1();
		Collection<String> c = this.buildStringList2();
		String[] newArray = ArrayTools.addAll(a, 3, c);

		assertEquals(6, newArray.length);
		assertTrue(ArrayTools.containsAll(newArray, c));
	}

	public void testAddAllObjectArrayIntCollection_EmptyArray() {
		String[] a = new String[0];
		Collection<String> c = this.buildStringList2();
		String[] newArray = ArrayTools.addAll(a, 0, c);

		assertEquals(3, newArray.length);
		assertTrue(ArrayTools.containsAll(newArray, c));
	}

	public void testAddAllObjectArrayIntCollection_EmptyArray_Exception() {
		String[] a = new String[0];
		Collection<String> c = this.buildStringList2();
		boolean exCaught = false;
		try {
			String[] newArray = ArrayTools.addAll(a, 3, c);
			fail("bogus array: " + Arrays.toString(newArray));
		} catch (IndexOutOfBoundsException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);
	}

	public void testAddAllObjectArrayIntCollection_EmptyCollection() {
		String[] a = this.buildStringArray1();
		Collection<String> c = new ArrayList<String>();
		String[] newArray = ArrayTools.addAll(a, 1, c);

		assertEquals(3, newArray.length);
	}

	public void testAddAllObjectArrayIntIterable_String() {
		String[] a = this.buildStringArray1();
		Iterable<String> iterable = this.buildStringList2();
		String[] newArray = ArrayTools.addAll(a, 1, iterable);

		assertEquals(6, newArray.length);
		assertTrue(ArrayTools.containsAll(newArray, iterable));
	}

	public void testAddAllObjectArrayIntIterable_EmptyArray() {
		String[] a = new String[0];
		Iterable<String> iterable = this.buildStringList2();
		String[] newArray = ArrayTools.addAll(a, 0, iterable);

		assertEquals(3, newArray.length);
		assertTrue(ArrayTools.containsAll(newArray, iterable));
	}

	public void testAddAllObjectArrayIntIterable_EmptyIterable() {
		String[] a = this.buildStringArray1();
		Iterable<String> iterable = new ArrayList<String>();
		String[] newArray = ArrayTools.addAll(a, 1, iterable);

		assertEquals(3, newArray.length);
	}

	public void testAddAllObjectArrayIntIterableInt_String() {
		String[] a = this.buildStringArray1();
		Iterable<String> iterable = this.buildStringList2();
		String[] newArray = ArrayTools.addAll(a, 1, iterable, 3);

		assertEquals(6, newArray.length);
		assertTrue(ArrayTools.containsAll(newArray, iterable));
	}

	public void testAddAllObjectArrayIntIterableInt_EmptyArray() {
		String[] a = new String[0];
		Iterable<String> iterable = this.buildStringList2();
		String[] newArray = ArrayTools.addAll(a, 0, iterable, 3);

		assertEquals(3, newArray.length);
		assertTrue(ArrayTools.containsAll(newArray, iterable));
	}

	public void testAddAllObjectArrayIntIterableInt_EmptyIterable() {
		String[] a = this.buildStringArray1();
		Iterable<String> iterable = new ArrayList<String>();
		String[] newArray = ArrayTools.addAll(a, 1, iterable, 0);

		assertEquals(3, newArray.length);
	}

	public void testAddAllObjectArrayIntIterator_String() {
		String[] a = this.buildStringArray1();
		Iterator<String> iterator = this.buildStringList2().iterator();
		String[] newArray = ArrayTools.addAll(a, 1, iterator);

		assertEquals(6, newArray.length);
		assertTrue(ArrayTools.containsAll(newArray, this.buildStringList2()));
	}

	public void testAddAllObjectArrayIntIterator_EmptyArray() {
		String[] a = new String[0];
		Iterator<String> iterator = this.buildStringList2().iterator();
		String[] newArray = ArrayTools.addAll(a, 0, iterator);

		assertEquals(3, newArray.length);
		assertTrue(ArrayTools.containsAll(newArray, this.buildStringList2()));
	}

	public void testAddAllObjectArrayIntIterator_EmptyIterable() {
		String[] a = this.buildStringArray1();
		Iterator<String> iterator = EmptyIterator.instance();
		String[] newArray = ArrayTools.addAll(a, 1, iterator);

		assertEquals(3, newArray.length);
	}

	public void testAddAllObjectArrayIntIteratorInt_String() {
		String[] a = this.buildStringArray1();
		Iterator<String> iterator = this.buildStringList2().iterator();
		String[] newArray = ArrayTools.addAll(a, 1, iterator, 3);

		assertEquals(6, newArray.length);
		assertTrue(ArrayTools.containsAll(newArray, this.buildStringList2()));
	}

	public void testAddAllObjectArrayIntIteratorInt_EmptyArray() {
		String[] a = new String[0];
		Iterator<String> iterator = this.buildStringList2().iterator();
		String[] newArray = ArrayTools.addAll(a, 0, iterator, 3);

		assertEquals(3, newArray.length);
		assertTrue(ArrayTools.containsAll(newArray, this.buildStringList2()));
	}

	public void testAddAllObjectArrayIntIteratorInt_EmptyIterator() {
		String[] a = this.buildStringArray1();
		Iterator<String> iterator = EmptyIterator.instance();
		String[] newArray = ArrayTools.addAll(a, 1, iterator, 0);

		assertEquals(3, newArray.length);
	}

	public void testAddAllObjectArrayIterable() {
		String[] a = this.buildStringArray1();
		Iterable<String> iterable = this.buildStringList1();
		String[] newArray = ArrayTools.addAll(a, iterable);

		assertEquals(6, newArray.length);
		assertTrue(ArrayTools.containsAll(newArray, this.buildStringList1()));
	}

	public void testAddAllObjectArrayIterableInt() {
		String[] a = this.buildStringArray1();
		Iterable<String> iterable = this.buildStringList1();
		String[] newArray = ArrayTools.addAll(a, iterable, 33);

		assertEquals(6, newArray.length);
		assertTrue(ArrayTools.containsAll(newArray, this.buildStringList1()));
	}

	public void testAddAllObjectArrayIterator_String() {
		String[] a = this.buildStringArray1();
		Iterator<String> iterator = this.buildStringList1().iterator();
		String[] newArray = ArrayTools.addAll(a, iterator);

		assertEquals(6, newArray.length);
		assertTrue(ArrayTools.containsAll(newArray, this.buildStringList1()));
	}

	public void testAddAllObjectArrayIterator_Object() {
		String[] a = this.buildStringArray1();
		Iterator<Object> iterator = this.buildObjectList1().iterator();
		Object[] newArray = ArrayTools.addAll(a, iterator);

		assertEquals(6, newArray.length);
		assertTrue(ArrayTools.containsAll(newArray, this.buildObjectList1()));
	}

	public void testAddAllObjectArrayIterator_EmptyIterator() {
		String[] a = this.buildStringArray1();
		Iterator<String> iterator = EmptyIterator.instance();
		String[] newArray = ArrayTools.addAll(a, iterator);

		assertEquals(3, newArray.length);
		assertTrue(ArrayTools.containsAll(newArray, this.buildStringList1()));
	}

	public void testAddAllObjectArrayIteratorInt() {
		String[] a = this.buildStringArray1();
		Iterator<Object> iterator = this.buildObjectList1().iterator();
		Object[] newArray = ArrayTools.addAll(a, iterator, 3);

		assertEquals(6, newArray.length);
		assertTrue(ArrayTools.containsAll(newArray, this.buildObjectList1()));
	}

	public void testAddAllObjectArrayIteratorInt_EmptyIterator() {
		String[] a = this.buildStringArray1();
		Iterator<String> iterator = EmptyIterator.instance();
		String[] newArray = ArrayTools.addAll(a, iterator, 0);

		assertEquals(3, newArray.length);
		assertTrue(ArrayTools.containsAll(newArray, this.buildStringList1()));
	}

	public void testAddAllObjectArrayObjectArray_Object() {
		Object[] a1 = this.buildObjectArray1();
		Object[] a2 = this.buildObjectArray2();
		Object[] newArray = ArrayTools.addAll(a1, a2);

		assertEquals(6, newArray.length);
		assertTrue(ArrayTools.containsAll(newArray, a1));
		assertTrue(ArrayTools.containsAll(newArray, a2));
	}

	public void testAddAllObjectArrayObjectArray_String() {
		String[] a1 = this.buildStringArray1();
		String[] a2 = this.buildStringArray2();
		String[] newArray = ArrayTools.addAll(a1, a2);

		assertEquals(6, newArray.length);
		assertTrue(ArrayTools.containsAll(newArray, (Object[]) a1));
		assertTrue(ArrayTools.containsAll(newArray, (Object[]) a2));
	}

	public void testAddAllObjectArrayObjectArray_ObjectString() {
		Object[] a1 = this.buildObjectArray1();
		String[] a2 = this.buildStringArray2();
		Object[] newArray = ArrayTools.addAll(a1, (Object[]) a2);

		assertEquals(6, newArray.length);
		assertTrue(ArrayTools.containsAll(newArray, a1));
		assertTrue(ArrayTools.containsAll(newArray, (Object[]) a2));
	}

	public void testAddAllObjectArrayObjectArray_EmptyArray1() {
		Object[] a1 = new Object[0];
		Object[] a2 = this.buildObjectArray2();
		Object[] newArray = ArrayTools.addAll(a1, a2);

		assertEquals(3, newArray.length);
		assertTrue(ArrayTools.containsAll(newArray, a2));
	}

	public void testAddAllObjectArrayObjectArray_EmptyArray2() {
		Object[] a1 = this.buildObjectArray1();
		Object[] a2 = new Object[0];
		Object[] newArray = ArrayTools.addAll(a1, a2);

		assertEquals(3, newArray.length);
		assertTrue(ArrayTools.containsAll(newArray, a1));
	}

	public void testAddAllObjectArrayIntObjectArray_Object() {
		Object[] a = new Object[] { "a", "b", "c", "d" };
		a = ArrayTools.addAll(a, 2, new Object[] { "X", "X", "X" });
		assertEquals(7, a.length);
		assertTrue(ArrayTools.contains(a, "X"));
		assertTrue(Arrays.equals(new Object[] { "a", "b", "X", "X", "X", "c", "d" }, a));
	}

	public void testAddAllObjectArrayIntObjectArray_String() {
		String[] a = new String[] { "a", "b", "c", "d" };
		a = ArrayTools.addAll(a, 2, new String[] { "X", "X", "X" });
		assertEquals(7, a.length);
		assertTrue(ArrayTools.contains(a, "X"));
		assertTrue(Arrays.equals(new String[] { "a", "b", "X", "X", "X", "c", "d" }, a));
	}

	public void testAddAllObjectArrayIntObjectArray_ObjectString() {
		Object[] a = new Object[] { "a", "b", "c", "d" };
		a = ArrayTools.addAll(a, 2, (Object[]) new String[] { "X", "X", "X" });
		assertEquals(7, a.length);
		assertTrue(ArrayTools.contains(a, "X"));
		assertTrue(Arrays.equals(new Object[] { "a", "b", "X", "X", "X", "c", "d" }, a));
	}

	public void testAddAllObjectArrayIntObjectArray_End() {
		Object[] a = new Object[] { "a", "b", "c", "d" };
		a = ArrayTools.addAll(a, 4, (Object[]) new String[] { "X", "X", "X" });
		assertEquals(7, a.length);
		assertTrue(ArrayTools.contains(a, "X"));
		assertTrue(Arrays.equals(new Object[] { "a", "b", "c", "d", "X", "X", "X" }, a));
	}

	public void testAddAllObjectArrayIntObjectArray_Zero() {
		Object[] a = new Object[0];
		a = ArrayTools.addAll(a, 0, (Object[]) new String[] { "X", "X", "X" });
		assertEquals(3, a.length);
		assertTrue(ArrayTools.contains(a, "X"));
		assertTrue(Arrays.equals(new Object[] { "X", "X", "X" }, a));
	}

	public void testAddAllObjectArrayIntObjectArray_EmptyArray2() {
		Object[] a = new Object[] { "a", "b", "c", "d" };
		a = ArrayTools.addAll(a, 4, (Object[]) new String[0]);
		assertEquals(4, a.length);
		assertTrue(Arrays.equals(new Object[] { "a", "b", "c", "d" }, a));
	}

	public void testAddAllObjectArrayIntObjectArray_EmptyArray1() {
		Object[] a = new String[0];
		a = ArrayTools.addAll(a, 0, new Object[] { "a", "b", "c", "d" });
		assertEquals(4, a.length);
		assertTrue(Arrays.equals(new Object[] { "a", "b", "c", "d" }, a));
	}

	public void testAddAllCharArrayCharArray() {
		char[] a = ArrayTools.addAll(this.buildCharArray(), new char[] { 'd', 'e' });
		assertEquals(5, a.length);
		assertTrue(ArrayTools.contains(a, 'd'));
		assertTrue(ArrayTools.contains(a, 'e'));
	}

	public void testAddAllCharArrayCharArray_EmptyArray2() {
		char[] a = ArrayTools.addAll(this.buildCharArray(), new char[0]);
		assertEquals(3, a.length);
	}

	public void testAddAllCharArrayCharArrayEmptyArray1() {
		char[] a = ArrayTools.addAll(new char[0], new char[] { 'd', 'e' });
		assertEquals(2, a.length);
		assertTrue(ArrayTools.contains(a, 'd'));
		assertTrue(ArrayTools.contains(a, 'e'));
	}

	public void testAddAllCharArrayIntCharArray() {
		char[] a = new char[] { 'a', 'b', 'c', 'd' };
		a = ArrayTools.addAll(a, 2, new char[] { 'X', 'X', 'X' });
		assertEquals(7, a.length);
		assertTrue(ArrayTools.contains(a, 'X'));
		assertTrue(Arrays.equals(new char[] { 'a', 'b', 'X', 'X', 'X', 'c', 'd' }, a));
	}

	public void testAddAllCharArrayIntCharArray_End() {
		char[] a = new char[] { 'a', 'b', 'c', 'd' };
		a = ArrayTools.addAll(a, 4, new char[] { 'X', 'X', 'X' });
		assertEquals(7, a.length);
		assertTrue(ArrayTools.contains(a, 'X'));
		assertTrue(Arrays.equals(new char[] { 'a', 'b', 'c', 'd', 'X', 'X', 'X' }, a));
	}

	public void testAddAllCharArrayIntCharArray_EmptyArray1() {
		char[] a = new char[0];
		a = ArrayTools.addAll(a, 0, new char[] { 'X', 'X', 'X' });
		assertEquals(3, a.length);
		assertTrue(ArrayTools.contains(a, 'X'));
		assertTrue(Arrays.equals(new char[] { 'X', 'X', 'X' }, a));
	}

	public void testAddAllCharArrayIntCharArray_EmptyArray2() {
		char[] a = new char[] { 'a', 'b', 'c', 'd' };
		a = ArrayTools.addAll(a, 2, new char[0]);
		assertEquals(4, a.length);
		assertTrue(Arrays.equals(new char[] { 'a', 'b', 'c', 'd' }, a));
	}

	public void testAddAllIntArrayIntArray() {
		int[] a = ArrayTools.addAll(this.buildIntArray(), new int[] { 30, 40 });
		assertEquals(5, a.length);
		assertTrue(ArrayTools.contains(a, 30));
		assertTrue(ArrayTools.contains(a, 40));
	}

	public void testAddAllIntArrayIntArray_EmptyArray2() {
		int[] a = ArrayTools.addAll(this.buildIntArray(), new int[0]);
		assertEquals(3, a.length);
	}

	public void testAddAllIntArrayIntArray_EmptyArray1() {
		int[] a = ArrayTools.addAll(new int[0], new int[] { 30, 40 });
		assertEquals(2, a.length);
		assertTrue(ArrayTools.contains(a, 30));
		assertTrue(ArrayTools.contains(a, 40));
	}

	public void testAddAllIntArrayIntIntArray() {
		int[] a = new int[] { 1, 2, 3, 4 };
		a = ArrayTools.addAll(a, 2, new int[] { 99, 99, 99 });
		assertEquals(7, a.length);
		assertTrue(ArrayTools.contains(a, 99));
		assertTrue(Arrays.equals(new int[] { 1, 2, 99, 99, 99, 3, 4 }, a));
	}

	public void testAddAllIntArrayIntIntArray_End() {
		int[] a = new int[] { 1, 2, 3, 4 };
		a = ArrayTools.addAll(a, 4, new int[] { 99, 99, 99 });
		assertEquals(7, a.length);
		assertTrue(ArrayTools.contains(a, 99));
		assertTrue(Arrays.equals(new int[] { 1, 2, 3, 4, 99, 99, 99 }, a));
	}

	public void testAddAllIntArrayIntIntArray_EmptyArray2() {
		int[] a = new int[] { 1, 2, 3, 4 };
		a = ArrayTools.addAll(a, 2, new int[0]);
		assertEquals(4, a.length);
		assertTrue(Arrays.equals(new int[] { 1, 2, 3, 4 }, a));
	}

	public void testAddAllIntArrayIntIntArray_EmptyArray1() {
		int[] a = new int[0];
		a = ArrayTools.addAll(a, 0, new int[] { 99, 99, 99 });
		assertEquals(3, a.length);
		assertTrue(ArrayTools.contains(a, 99));
		assertTrue(Arrays.equals(new int[] { 99, 99, 99 }, a));
	}


	// ********** clear **********

	public void testClearObjectArray() {
		String[] a = this.buildStringArray1();
		assertEquals(3, a.length);
		a = ArrayTools.clear(a);
		assertEquals(0, a.length);
	}

	public void testClearObjectArray_Empty() {
		String[] a = new String[0];
		assertEquals(0, a.length);
		a = ArrayTools.clear(a);
		assertEquals(0, a.length);
	}


	// ********** concatenate **********

	public void testConcatenateObjectArrayArray() {
		String[] aArray = new String[] { "a", "b", "c", "d" };
		String[] eArray = new String[] { "e", "f", "g", "h" };
		String[] iArray = new String[] { "i", "j", "k", "l" };

		String[] expected = new String[] { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l" };
		String[] actual = ArrayTools.concatenate(aArray, eArray, iArray);
		assertTrue(Arrays.equals(expected, actual));
	}

	public void testConcatenateObjectArrayArray_Empty() {
		String[] aArray = new String[] {  };
		String[] eArray = new String[0];
		String[] iArray = new String[0];

		String[] expected = new String[0];
		String[] actual = ArrayTools.concatenate(aArray, eArray, iArray);
		assertEquals(0, actual.length);
		assertTrue(Arrays.equals(expected, actual));
	}

	public void testConcatenateCharArrayArray() {
		char[] aArray = new char[] { 'a', 'b', 'c', 'd' };
		char[] eArray = new char[] { 'e', 'f', 'g', 'h' };
		char[] iArray = new char[] { 'i', 'j', 'k', 'l' };

		char[] expected = new char[] { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l' };
		char[] actual = ArrayTools.concatenate(aArray, eArray, iArray);
		assertTrue(Arrays.equals(expected, actual));
	}

	public void testConcatenateCharArrayArray_Empty() {
		char[] aArray = new char[] {  };
		char[] eArray = new char[0];
		char[] iArray = new char[0];

		char[] expected = new char[0];
		char[] actual = ArrayTools.concatenate(aArray, eArray, iArray);
		assertEquals(0, actual.length);
		assertTrue(Arrays.equals(expected, actual));
	}

	public void testConcatenateIntArrayArray() {
		int[] aArray = new int[] { 'a', 'b', 'c', 'd' };
		int[] eArray = new int[] { 'e', 'f', 'g', 'h' };
		int[] iArray = new int[] { 'i', 'j', 'k', 'l' };

		int[] expected = new int[] { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l' };
		int[] actual = ArrayTools.concatenate(aArray, eArray, iArray);
		assertTrue(Arrays.equals(expected, actual));
	}

	public void testConcatenateIntArrayArray_Empty() {
		int[] aArray = new int[] {  };
		int[] eArray = new int[0];
		int[] iArray = new int[0];

		int[] expected = new int[0];
		int[] actual = ArrayTools.concatenate(aArray, eArray, iArray);
		assertEquals(0, actual.length);
		assertTrue(Arrays.equals(expected, actual));
	}


	// ********** contains **********

	public void testContainsObjectArrayObject() {
		Object[] a = this.buildObjectArray1();
		assertTrue(ArrayTools.contains(a, "one"));
		assertFalse(ArrayTools.contains(a, null));
		Object[] a2 = ArrayTools.add(a, null);
		assertTrue(ArrayTools.contains(a2, null));
	}

	public void testContainsObjectArrayObject_EmptyArray() {
		Object[] a = new Object[0];
		assertFalse(ArrayTools.contains(a, "one"));
		assertFalse(ArrayTools.contains(a, null));
	}

	public void testContainsCharArrayChar() {
		char[] a = this.buildCharArray();
		assertTrue(ArrayTools.contains(a, 'a'));
		assertFalse(ArrayTools.contains(a, 'z'));
		char[] a2 = ArrayTools.add(a, 'z');
		assertTrue(ArrayTools.contains(a2, 'z'));
	}

	public void testContainsCharArrayObject_EmptyArray() {
		char[] a = new char[0];
		assertFalse(ArrayTools.contains(a, 'a'));
	}

	public void testContainsIntArrayInt() {
		int[] a = this.buildIntArray();
		assertTrue(ArrayTools.contains(a, 10));
		assertFalse(ArrayTools.contains(a, 55));
		int[] a2 = ArrayTools.add(a, 55);
		assertTrue(ArrayTools.contains(a2, 55));
	}

	public void testContainsIntArrayObject_EmptyArray() {
		int[] a = new int[0];
		assertFalse(ArrayTools.contains(a, 'a'));
	}


	// ********** contains all **********

	public void testContainsAllObjectArrayCollection() {
		assertTrue(ArrayTools.containsAll(this.buildObjectArray1(), this.buildStringList1()));
		assertFalse(ArrayTools.containsAll(this.buildObjectArray1(), this.buildStringList2()));
	}

	public void testContainsAllObjectArrayIterable() {
		Iterable<String> iterable = this.buildStringList1();
		assertTrue(ArrayTools.containsAll(this.buildObjectArray1(), iterable));
		iterable = this.buildStringList2();
		assertFalse(ArrayTools.containsAll(this.buildObjectArray1(), iterable));
	}

	public void testContainsAllObjectArrayIterator() {
		assertTrue(ArrayTools.containsAll(this.buildObjectArray1(), this.buildStringList1().iterator()));
		assertFalse(ArrayTools.containsAll(this.buildObjectArray1(), this.buildStringList2().iterator()));
	}

	public void testContainsAllObjectArrayIterator_Empty() {
		assertTrue(ArrayTools.containsAll(this.buildObjectArray1(), EmptyIterator.instance()));
	}

	public void testContainsAllObjectArrayObjectArray() {
		assertTrue(ArrayTools.containsAll(this.buildObjectArray1(), this.buildObjectArray1()));
		assertFalse(ArrayTools.containsAll(this.buildObjectArray1(), this.buildObjectArray2()));
	}

	public void testContainsAllCharArrayCharArray() {
		assertTrue(ArrayTools.containsAll(this.buildCharArray(), this.buildCharArray()));
		assertFalse(ArrayTools.containsAll(this.buildCharArray(), new char[] { 'x', 'y' }));
	}

	public void testContainsAllIntArrayIntArray() {
		assertTrue(ArrayTools.containsAll(this.buildIntArray(), this.buildIntArray()));
		assertFalse(ArrayTools.containsAll(this.buildIntArray(), new int[] { 444, 888 }));
	}


	// ********** diff **********

	public void testDiffEnd() {
		String a = "a";
		String b = "b";
		String c = "c";
		String d = "d";
		String e = "e";
		String a_ = new String("a");
		String b_ = new String("b");
		String c_ = new String("c");
		String d_ = new String("d");
		String e_ = new String("e");
		assertTrue((a != a_) && a.equals(a_));
		assertTrue((b != b_) && b.equals(b_));
		assertTrue((c != c_) && c.equals(c_));
		assertTrue((d != d_) && d.equals(d_));
		assertTrue((e != e_) && e.equals(e_));
		String[] array1;
		String[] array2;

		array1 = new String[] { a, b, c, d, e };
		array2 = new String[] { a_, b_, c_, d_, e_ };
		assertEquals(-1, ArrayTools.diffEnd(array1, array2));

		array1 = new String[] { a };
		array2 = new String[] { a_ };
		assertEquals(-1, ArrayTools.diffEnd(array1, array2));

		array1 = new String[] { b, c, d, e };
		array2 = new String[] { a_, b_, c_, d_, e_ };
		assertEquals(4, ArrayTools.diffEnd(array1, array2));

		array1 = new String[] { a, b, c, d, e };
		array2 = new String[] { b_, c_, d_, e_ };
		assertEquals(4, ArrayTools.diffEnd(array1, array2));

		array1 = new String[0];
		array2 = new String[] { a_, b_, c_, d_, e_ };
		assertEquals(4, ArrayTools.diffEnd(array1, array2));

		array1 = new String[] { a, b, c, d, e };
		array2 = new String[0];
		assertEquals(4, ArrayTools.diffEnd(array1, array2));

		array1 = new String[0];
		array2 = new String[0];
		assertEquals(-1, ArrayTools.diffEnd(array1, array2));

		array1 = new String[] { a, b, c, d, e };
		array2 = new String[] { b_, c_, a_, d_, e_ };
		assertEquals(2, ArrayTools.diffEnd(array1, array2));

		array1 = new String[] { b, c, d, e };
		array2 = new String[] { a_, c_, d_, e_ };
		assertEquals(0, ArrayTools.diffEnd(array1, array2));

		array1 = new String[] { a, b, c, e };
		array2 = new String[] { a_, b_, c_, d_ };
		assertEquals(3, ArrayTools.diffEnd(array1, array2));

		String c__ = new String(c);
		assertTrue((c != c__) && c.equals(c_));
		array1 = new String[] { a, b, c, d, e };
		array2 = new String[] { a_, b_, c__, d_, e_ };
		assertEquals(-1, ArrayTools.diffEnd(array1, array2));

		array1 = new String[] { a, b, null, d, e };
		array2 = new String[] { a_, b_, c_, d_, e_ };
		assertEquals(2, ArrayTools.diffEnd(array1, array2));

		array1 = new String[] { a, b, null, d, e };
		array2 = new String[] { a_, b_, null, d_, e_ };
		assertEquals(-1, ArrayTools.diffEnd(array1, array2));
	}

	public void testDiffRange() {
		String a = "a";
		String b = "b";
		String c = "c";
		String d = "d";
		String e = "e";
		String a_ = a;
		String b_ = b;
		String c_ = c;
		String d_ = d;
		String e_ = e;
		assertTrue((a == a_) && a.equals(a_));
		assertTrue((b == b_) && b.equals(b_));
		assertTrue((c == c_) && c.equals(c_));
		assertTrue((d == d_) && d.equals(d_));
		assertTrue((e == e_) && e.equals(e_));
		String[] array1;
		String[] array2;

		array1 = new String[] { a, b, c, d, e };
		array2 = new String[] { a_, b_, c_, d_, e_ };
		assertEquals(new Range(5, -1), ArrayTools.diffRange(array1, array2));

		array1 = new String[] { a };
		array2 = new String[] { a_ };
		assertEquals(new Range(1, -1), ArrayTools.diffRange(array1, array2));

		array1 = new String[] { b, c, d, e };
		array2 = new String[] { a_, b_, c_, d_, e_ };
		assertEquals(new Range(0, 4), ArrayTools.diffRange(array1, array2));

		array1 = new String[] { a, b, c, d, e };
		array2 = new String[] { b_, c_, d_, e_ };
		assertEquals(new Range(0, 4), ArrayTools.diffRange(array1, array2));

		array1 = new String[0];
		array2 = new String[] { a_, b_, c_, d_, e_ };
		assertEquals(new Range(0, 4), ArrayTools.diffRange(array1, array2));

		array1 = new String[] { a, b, c, d, e };
		array2 = new String[0];
		assertEquals(new Range(0, 4), ArrayTools.diffRange(array1, array2));

		array1 = new String[0];
		array2 = new String[0];
		assertEquals(new Range(0, -1), ArrayTools.diffRange(array1, array2));

		array1 = new String[] { a, b, c, d, e };
		array2 = new String[] { b_, c_, a_, d_, e_ };
		assertEquals(new Range(0, 2), ArrayTools.diffRange(array1, array2));

		array1 = new String[] { b, c, d, e };
		array2 = new String[] { a_, c_, d_, e_ };
		assertEquals(new Range(0, 0), ArrayTools.diffRange(array1, array2));

		array1 = new String[] { a, b, c, e };
		array2 = new String[] { a_, b_, c_, d_ };
		assertEquals(new Range(3, 3), ArrayTools.diffRange(array1, array2));

		String c__ = new String(c);
		assertTrue((c != c__) && c.equals(c_));
		array1 = new String[] { a, b, c, d, e };
		array2 = new String[] { a_, b_, c__, d_, e_ };
		assertEquals(new Range(5, -1), ArrayTools.diffRange(array1, array2));

		array1 = new String[] { a, b, null, d, e };
		array2 = new String[] { a_, b_, c_, d_, e_ };
		assertEquals(new Range(2, 2), ArrayTools.diffRange(array1, array2));

		array1 = new String[] { a, b, null, d, e };
		array2 = new String[] { a_, b_, null, d_, e_ };
		assertEquals(new Range(5, -1), ArrayTools.diffRange(array1, array2));
	}

	public void testDiffStart() {
		String a = "a";
		String b = "b";
		String c = "c";
		String d = "d";
		String e = "e";
		String a_ = new String("a");
		String b_ = new String("b");
		String c_ = new String("c");
		String d_ = new String("d");
		String e_ = new String("e");
		assertTrue((a != a_) && a.equals(a_));
		assertTrue((b != b_) && b.equals(b_));
		assertTrue((c != c_) && c.equals(c_));
		assertTrue((d != d_) && d.equals(d_));
		assertTrue((e != e_) && e.equals(e_));
		String[] array1;
		String[] array2;

		array1 = new String[] { a, b, c, d, e };
		array2 = new String[] { a_, b_, c_, d_, e_ };
		assertEquals(5, ArrayTools.diffStart(array1, array2));

		array1 = new String[] { a };
		array2 = new String[] { a_ };
		assertEquals(1, ArrayTools.diffStart(array1, array2));

		array1 = new String[] { a, b, c, d };
		array2 = new String[] { a_, b_, c_, d_, e_ };
		assertEquals(4, ArrayTools.diffStart(array1, array2));

		array1 = new String[] { a, b, c, d, e };
		array2 = new String[] { a_, b_, c_, d_ };
		assertEquals(4, ArrayTools.diffStart(array1, array2));

		array1 = new String[0];
		array2 = new String[] { a_, b_, c_, d_, e_ };
		assertEquals(0, ArrayTools.diffStart(array1, array2));

		array1 = new String[] { a, b, c, d, e };
		array2 = new String[0];
		assertEquals(0, ArrayTools.diffStart(array1, array2));

		array1 = new String[0];
		array2 = new String[0];
		assertEquals(0, ArrayTools.diffStart(array1, array2));

		array1 = new String[] { a, b, c, d, e };
		array2 = new String[] { a_, b_, e_, c_, d_ };
		assertEquals(2, ArrayTools.diffStart(array1, array2));

		array1 = new String[] { a, b, c, e };
		array2 = new String[] { a_, b_, c_, d_ };
		assertEquals(3, ArrayTools.diffStart(array1, array2));

		array1 = new String[] { b, c, d, e };
		array2 = new String[] { a_, c_, d_, e_ };
		assertEquals(0, ArrayTools.diffStart(array1, array2));

		String c__ = new String(c);
		assertTrue((c != c__) && c.equals(c__));
		array1 = new String[] { a, b, c, d, e };
		array2 = new String[] { a_, b_, c__, d_, e_ };
		assertEquals(5, ArrayTools.diffStart(array1, array2));

		array1 = new String[] { a, b, null, d, e };
		array2 = new String[] { a_, b_, c_, d_, e_ };
		assertEquals(2, ArrayTools.diffStart(array1, array2));

		array1 = new String[] { a, b, null, d, e };
		array2 = new String[] { a_, b_, null, d_, e_ };
		assertEquals(5, ArrayTools.diffStart(array1, array2));
	}


	// ********** identity diff **********

	public void testIdentityDiffEnd() {
		String a = "a";
		String b = "b";
		String c = "c";
		String d = "d";
		String e = "e";
		String a_ = a;
		String b_ = b;
		String c_ = c;
		String d_ = d;
		String e_ = e;
		assertTrue((a == a_) && a.equals(a_));
		assertTrue((b == b_) && b.equals(b_));
		assertTrue((c == c_) && c.equals(c_));
		assertTrue((d == d_) && d.equals(d_));
		assertTrue((e == e_) && e.equals(e_));
		String[] array1;
		String[] array2;

		array1 = new String[] { a, b, c, d, e };
		array2 = new String[] { a_, b_, c_, d_, e_ };
		assertEquals(-1, ArrayTools.identityDiffEnd(array1, array2));

		array1 = new String[] { a };
		array2 = new String[] { a_ };
		assertEquals(-1, ArrayTools.identityDiffEnd(array1, array2));

		array1 = new String[] { b, c, d, e };
		array2 = new String[] { a_, b_, c_, d_, e_ };
		assertEquals(4, ArrayTools.identityDiffEnd(array1, array2));

		array1 = new String[] { a, b, c, d, e };
		array2 = new String[] { b_, c_, d_, e_ };
		assertEquals(4, ArrayTools.identityDiffEnd(array1, array2));

		array1 = new String[0];
		array2 = new String[] { a_, b_, c_, d_, e_ };
		assertEquals(4, ArrayTools.identityDiffEnd(array1, array2));

		array1 = new String[] { a, b, c, d, e };
		array2 = new String[0];
		assertEquals(4, ArrayTools.identityDiffEnd(array1, array2));

		array1 = new String[0];
		array2 = new String[0];
		assertEquals(-1, ArrayTools.identityDiffEnd(array1, array2));

		array1 = new String[] { a, b, c, d, e };
		array2 = new String[] { b_, c_, a_, d_, e_ };
		assertEquals(2, ArrayTools.identityDiffEnd(array1, array2));

		array1 = new String[] { b, c, d, e };
		array2 = new String[] { a_, c_, d_, e_ };
		assertEquals(0, ArrayTools.identityDiffEnd(array1, array2));

		array1 = new String[] { a, b, c, e };
		array2 = new String[] { a_, b_, c_, d_ };
		assertEquals(3, ArrayTools.identityDiffEnd(array1, array2));

		String c__ = new String(c);
		assertTrue((c != c__) && c.equals(c_));
		array1 = new String[] { a, b, c, d, e };
		array2 = new String[] { a_, b_, c__, d_, e_ };
		assertEquals(2, ArrayTools.identityDiffEnd(array1, array2));

		array1 = new String[] { a, b, null, d, e };
		array2 = new String[] { a_, b_, c_, d_, e_ };
		assertEquals(2, ArrayTools.identityDiffEnd(array1, array2));

		array1 = new String[] { a, b, null, d, e };
		array2 = new String[] { a_, b_, null, d_, e_ };
		assertEquals(-1, ArrayTools.identityDiffEnd(array1, array2));
	}

	public void testIdentityDiffRange() {
		String a = "a";
		String b = "b";
		String c = "c";
		String d = "d";
		String e = "e";
		String a_ = a;
		String b_ = b;
		String c_ = c;
		String d_ = d;
		String e_ = e;
		assertTrue((a == a_) && a.equals(a_));
		assertTrue((b == b_) && b.equals(b_));
		assertTrue((c == c_) && c.equals(c_));
		assertTrue((d == d_) && d.equals(d_));
		assertTrue((e == e_) && e.equals(e_));
		String[] array1;
		String[] array2;

		array1 = new String[] { a, b, c, d, e };
		array2 = new String[] { a_, b_, c_, d_, e_ };
		assertEquals(new Range(5, -1), ArrayTools.identityDiffRange(array1, array2));

		array1 = new String[] { a };
		array2 = new String[] { a_ };
		assertEquals(new Range(1, -1), ArrayTools.identityDiffRange(array1, array2));

		array1 = new String[] { b, c, d, e };
		array2 = new String[] { a_, b_, c_, d_, e_ };
		assertEquals(new Range(0, 4), ArrayTools.identityDiffRange(array1, array2));

		array1 = new String[] { a, b, c, d, e };
		array2 = new String[] { b_, c_, d_, e_ };
		assertEquals(new Range(0, 4), ArrayTools.identityDiffRange(array1, array2));

		array1 = new String[0];
		array2 = new String[] { a_, b_, c_, d_, e_ };
		assertEquals(new Range(0, 4), ArrayTools.identityDiffRange(array1, array2));

		array1 = new String[] { a, b, c, d, e };
		array2 = new String[0];
		assertEquals(new Range(0, 4), ArrayTools.identityDiffRange(array1, array2));

		array1 = new String[0];
		array2 = new String[0];
		assertEquals(new Range(0, -1), ArrayTools.identityDiffRange(array1, array2));

		array1 = new String[] { a, b, c, d, e };
		array2 = new String[] { b_, c_, a_, d_, e_ };
		assertEquals(new Range(0, 2), ArrayTools.identityDiffRange(array1, array2));

		array1 = new String[] { b, c, d, e };
		array2 = new String[] { a_, c_, d_, e_ };
		assertEquals(new Range(0, 0), ArrayTools.identityDiffRange(array1, array2));

		array1 = new String[] { a, b, c, e };
		array2 = new String[] { a_, b_, c_, d_ };
		assertEquals(new Range(3, 3), ArrayTools.identityDiffRange(array1, array2));

		String c__ = new String(c);
		assertTrue((c != c__) && c.equals(c_));
		array1 = new String[] { a, b, c, d, e };
		array2 = new String[] { a_, b_, c__, d_, e_ };
		assertEquals(new Range(2, 2), ArrayTools.identityDiffRange(array1, array2));

		array1 = new String[] { a, b, null, d, e };
		array2 = new String[] { a_, b_, c_, d_, e_ };
		assertEquals(new Range(2, 2), ArrayTools.identityDiffRange(array1, array2));

		array1 = new String[] { a, b, null, d, e };
		array2 = new String[] { a_, b_, null, d_, e_ };
		assertEquals(new Range(5, -1), ArrayTools.identityDiffRange(array1, array2));
	}

	public void testIdentityDiffStart() {
		String a = "a";
		String b = "b";
		String c = "c";
		String d = "d";
		String e = "e";
		String a_ = a;
		String b_ = b;
		String c_ = c;
		String d_ = d;
		String e_ = e;
		assertTrue((a == a_) && a.equals(a_));
		assertTrue((b == b_) && b.equals(b_));
		assertTrue((c == c_) && c.equals(c_));
		assertTrue((d == d_) && d.equals(d_));
		assertTrue((e == e_) && e.equals(e_));
		String[] array1;
		String[] array2;

		array1 = new String[] { a, b, c, d, e };
		array2 = new String[] { a_, b_, c_, d_, e_ };
		assertEquals(5, ArrayTools.identityDiffStart(array1, array2));

		array1 = new String[] { a };
		array2 = new String[] { a_ };
		assertEquals(1, ArrayTools.identityDiffStart(array1, array2));

		array1 = new String[] { a, b, c, d };
		array2 = new String[] { a_, b_, c_, d_, e_ };
		assertEquals(4, ArrayTools.identityDiffStart(array1, array2));

		array1 = new String[] { a, b, c, d, e };
		array2 = new String[] { a_, b_, c_, d_ };
		assertEquals(4, ArrayTools.identityDiffStart(array1, array2));

		array1 = new String[0];
		array2 = new String[] { a_, b_, c_, d_, e_ };
		assertEquals(0, ArrayTools.identityDiffStart(array1, array2));

		array1 = new String[] { a, b, c, d, e };
		array2 = new String[0];
		assertEquals(0, ArrayTools.identityDiffStart(array1, array2));

		array1 = new String[0];
		array2 = new String[0];
		assertEquals(0, ArrayTools.identityDiffStart(array1, array2));

		array1 = new String[] { a, b, c, d, e };
		array2 = new String[] { a_, b_, e_, c_, d_ };
		assertEquals(2, ArrayTools.identityDiffStart(array1, array2));

		array1 = new String[] { a, b, c, e };
		array2 = new String[] { a_, b_, c_, d_ };
		assertEquals(3, ArrayTools.identityDiffStart(array1, array2));

		array1 = new String[] { b, c, d, e };
		array2 = new String[] { a_, c_, d_, e_ };
		assertEquals(0, ArrayTools.identityDiffStart(array1, array2));

		String c__ = new String(c);
		assertTrue((c != c__) && c.equals(c_));
		array1 = new String[] { a, b, c, d, e };
		array2 = new String[] { a_, b_, c__, d_, e_ };
		assertEquals(2, ArrayTools.identityDiffStart(array1, array2));

		array1 = new String[] { a, b, null, d, e };
		array2 = new String[] { a_, b_, c_, d_, e_ };
		assertEquals(2, ArrayTools.identityDiffStart(array1, array2));

		array1 = new String[] { a, b, null, d, e };
		array2 = new String[] { a_, b_, null, d_, e_ };
		assertEquals(5, ArrayTools.identityDiffStart(array1, array2));
	}


	// ********** elements are identical **********

	public void testElementsAreIdenticalObjectArrayObjectArray() {
		Object[] a1 = new Object[4];
		for (int i = 0; i < a1.length; i++) {
			a1[i] = String.valueOf(i * 1000);
		}

		Object[] a2 = new Object[a1.length];
		for (int i = 0; i < a2.length; i++) {
			a2[i] = a1[i];
		}

		assertTrue(ArrayTools.elementsAreIdentical(a1, a2));
		a2[2] = "2000";
		assertFalse(ArrayTools.elementsAreIdentical(a1, a2));
		assertTrue(Arrays.equals(a1, a2));
	}

	public void testElementsAreIdenticalObjectArrayObjectArray_BothNull() {
		Object[] a1 = null;
		Object[] a2 = null;
		assertTrue(ArrayTools.elementsAreIdentical(a1, a2));
	}

	public void testElementsAreIdenticalObjectArrayObjectArray_OneNull() {
		Object[] a1 = null;
		Object[] a2 = new Object[0];
		assertFalse(ArrayTools.elementsAreIdentical(a1, a2));
	}

	public void testElementsAreIdenticalObjectArrayObjectArray_DifferentLengths() {
		Object[] a1 = new String[] {"foo", "bar"};
		Object[] a2 = new String[] {"foo", "bar", "baz"};
		assertFalse(ArrayTools.elementsAreIdentical(a1, a2));
	}


	// ********** index of **********

	public void testIndexOfObjectArrayObject() {
		Object[] a = this.buildObjectArray1();
		assertEquals(1, ArrayTools.indexOf(a, "one"));
	}

	public void testIndexOfObjectArrayObject_NotFound() {
		Object[] a = this.buildObjectArray1();
		assertEquals(-1, ArrayTools.indexOf(a, "twenty"));
	}

	public void testIndexOfObjectArrayObject_Null() {
		Object[] a = this.buildObjectArray1();
		a = ArrayTools.add(a, null);
		assertEquals(a.length - 1, ArrayTools.indexOf(a, null));
	}

	public void testIndexOfObjectArrayObject_Null_NotFound() {
		Object[] a = this.buildObjectArray1();
		assertEquals(-1, ArrayTools.indexOf(a, null));
	}

	public void testIdentityIndexOfObjectArrayObject() {
		String foo = "foo";
		String bar = "bar";
		String baz = "baz";
		Object[] a = new Object[3];
		a[0] = foo;
		a[1] = bar;
		a[2] = baz;
		assertEquals(1, ArrayTools.identityIndexOf(a, bar));
	}

	public void testIdentityIndexOfObjectArrayObject_NotFound() {
		String foo = "foo";
		String bar = "bar";
		String baz = "baz";
		Object[] a = new Object[3];
		a[0] = foo;
		a[1] = bar;
		a[2] = baz;
		assertEquals(-1, ArrayTools.identityIndexOf(a, new String("bar")));
	}

	public void testIndexOfCharArrayChar() {
		char[] a = this.buildCharArray();
		assertEquals(1, ArrayTools.indexOf(a, 'b'));
		a = ArrayTools.add(a, 'd');
		assertEquals(a.length - 1, ArrayTools.indexOf(a, 'd'));
	}

	public void testIndexOfCharArrayChar_NotFound() {
		char[] a = this.buildCharArray();
		assertEquals(-1, ArrayTools.indexOf(a, 'z'));
	}

	public void testIndexOfIntArrayInt() {
		int[] a = this.buildIntArray();
		assertEquals(1, ArrayTools.indexOf(a, 10));
		a = ArrayTools.add(a, 30);
		assertEquals(a.length - 1, ArrayTools.indexOf(a, 30));
	}

	public void testIndexOfIntArrayInt_NotFound() {
		int[] a = this.buildIntArray();
		assertEquals(-1, ArrayTools.indexOf(a, 1000));
	}


	// ********** insertion index of **********

	public void testInsertionIndexOfObjectArrayComparable() {
		String[] a = new String[] { "A", "C", "D" };
		assertEquals(1, ArrayTools.insertionIndexOf(a, "B"));

		a = new String[] { "A", "B", "C", "D" };
		assertEquals(2, ArrayTools.insertionIndexOf(a, "B"));

		a = new String[] { "A", "B", "B", "B", "C", "D" };
		assertEquals(4, ArrayTools.insertionIndexOf(a, "B"));

		a = new String[] { "A", "B", "B", "B", "C", "D" };
		assertEquals(6, ArrayTools.insertionIndexOf(a, "E"));

		a = new String[] { "B", "B", "B", "C", "D" };
		assertEquals(0, ArrayTools.insertionIndexOf(a, "A"));

		a = new String[] { "A", "A", "B", "B", "C", "D" };
		assertEquals(2, ArrayTools.insertionIndexOf(a, "A"));
	}

	public void testInsertionIndexOfObjectArrayObjectComparator() {
		Comparator<String> c = new ReverseComparator<String>();
		String[] a = new String[] { "D", "C", "A" };
		assertEquals(2, ArrayTools.insertionIndexOf(a, "B", c));

		a = new String[] { "D", "C", "B", "A" };
		assertEquals(3, ArrayTools.insertionIndexOf(a, "B", c));

		a = new String[] { "D", "C", "B", "B", "B", "A" };
		assertEquals(5, ArrayTools.insertionIndexOf(a, "B", c));

		a = new String[] { "D", "C", "B", "B", "B", "A" };
		assertEquals(0, ArrayTools.insertionIndexOf(a, "E", c));

		a = new String[] { "D", "C", "B", "B", "B" };
		assertEquals(5, ArrayTools.insertionIndexOf(a, "A", c));

		a = new String[] { "D", "C", "B", "B", "A", "A" };
		assertEquals(6, ArrayTools.insertionIndexOf(a, "A", c));
	}


	// ********** last index of **********

	public void testLastIndexOfObjectArrayObject() {
		Object[] a = this.buildObjectArray1();
		assertEquals(1, ArrayTools.lastIndexOf(a, "one"));
	}

	public void testLastIndexOfObjectArrayObject_NotFound() {
		Object[] a = this.buildObjectArray1();
		assertEquals(-1, ArrayTools.lastIndexOf(a, "twenty"));
	}

	public void testLastIndexOfObjectArrayObject_Null() {
		Object[] a = this.buildObjectArray1();
		a = ArrayTools.add(a, null);
		assertEquals(a.length - 1, ArrayTools.lastIndexOf(a, null));
	}

	public void testLastIndexOfObjectArrayObject_Null_NotFound() {
		Object[] a = this.buildObjectArray1();
		assertEquals(-1, ArrayTools.lastIndexOf(a, null));
	}

	public void testLastIndexOfCharArrayChar() {
		char[] a = this.buildCharArray();
		assertEquals(1, ArrayTools.lastIndexOf(a, 'b'));
		a = ArrayTools.add(a, 'd');
		assertEquals(a.length - 1, ArrayTools.lastIndexOf(a, 'd'));
	}

	public void testLastIndexOfCharArrayChar_NotFound() {
		char[] a = this.buildCharArray();
		assertEquals(-1, ArrayTools.lastIndexOf(a, 'z'));
	}

	public void testLastIndexOfIntArrayInt() {
		int[] a = this.buildIntArray();
		assertEquals(1, ArrayTools.lastIndexOf(a, 10));
		a = ArrayTools.add(a, 30);
		assertEquals(a.length - 1, ArrayTools.lastIndexOf(a, 30));
	}

	public void testLastIndexOfIntArrayInt_NotFound() {
		int[] a = this.buildIntArray();
		assertEquals(-1, ArrayTools.lastIndexOf(a, 1000));
	}


	// ********** min/max **********

	public void testMinCharArray() {
		assertEquals('a', ArrayTools.min(this.buildCharArray()));
	}

	public void testMinCharArray_Exception() {
		char[] array = new char[0];
		boolean exCaught = false;
		try {
			char c = ArrayTools.min(array);
			fail("bogus char: " + c);
		} catch (IndexOutOfBoundsException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);
	}

	public void testMinIntArray() {
		assertEquals(0, ArrayTools.min(this.buildIntArray()));
	}

	public void testMinIntArray_Exception() {
		int[] array = new int[0];
		boolean exCaught = false;
		try {
			int i = ArrayTools.min(array);
			fail("bogus int: " + i);
		} catch (IndexOutOfBoundsException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);
	}

	public void testMaxCharArray1() {
		assertEquals('c', ArrayTools.max(this.buildCharArray()));
	}

	public void testMaxCharArray2() {
		char[] array = new char[] { 'x', 'a', 'b', 'c' };
		assertEquals('x', ArrayTools.max(array));
	}

	public void testMaxCharArray_Exception() {
		char[] array = new char[0];
		boolean exCaught = false;
		try {
			char c = ArrayTools.max(array);
			fail("bogus char: " + c);
		} catch (IndexOutOfBoundsException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);
	}

	public void testMaxIntArray1() {
		assertEquals(20, ArrayTools.max(this.buildIntArray()));
	}

	public void testMaxIntArray2() {
		int[] array = new int[] { 77, 3, 1, -3 };
		assertEquals(77, ArrayTools.max(array));
	}

	public void testMaxIntArray_Exception() {
		int[] array = new int[0];
		boolean exCaught = false;
		try {
			int i = ArrayTools.max(array);
			fail("bogus int: " + i);
		} catch (IndexOutOfBoundsException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);
	}


	// ********** move **********

	public void testMoveObjectArrayIntInt() {
		String[] array = new String[] { "0", "1", "2", "3", "4", "5" };

		String[] result = ArrayTools.move(array, 4, 2);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new String[] { "0", "1", "3", "4", "2", "5" }, result));

		result = ArrayTools.move(array, 0, 5);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new String[] { "5", "0", "1", "3", "4", "2" }, result));

		result = ArrayTools.move(array, 2, 4);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new String[] { "5", "0", "4", "1", "3", "2" }, result));

		result = ArrayTools.move(array, 4, 4);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new String[] { "5", "0", "4", "1", "3", "2" }, result));
	}

	public void testMoveObjectArrayIntIntInt() {
		String[] array = new String[] { "0", "1", "2", "3", "4", "5" };

		String[] result = ArrayTools.move(array, 4, 2, 1);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new String[] { "0", "1", "3", "4", "2", "5" }, result));

		result = ArrayTools.move(array, 0, 5, 1);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new String[] { "5", "0", "1", "3", "4", "2" }, result));

		result = ArrayTools.move(array, 2, 4, 1);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new String[] { "5", "0", "4", "1", "3", "2" }, result));

		result = ArrayTools.move(array, 2, 4, 2);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new String[] { "5", "0", "3", "2", "4", "1" }, result));

		result = ArrayTools.move(array, 0, 1, 4);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new String[] { "0", "3", "2", "4", "5", "1" }, result));

		result = ArrayTools.move(array, 1, 0, 4);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new String[] { "5", "0", "3", "2", "4", "1" }, result));

		result = ArrayTools.move(array, 1, 1, 4);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new String[] { "5", "0", "3", "2", "4", "1" }, result));

		result = ArrayTools.move(array, 1, 0, 0);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new String[] { "5", "0", "3", "2", "4", "1" }, result));
	}

	public void testMoveIntArrayIntInt() {
		int[] array = new int[] { 0, 1, 2, 3, 4, 5 };

		int[] result = ArrayTools.move(array, 4, 2);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new int[] { 0, 1, 3, 4, 2, 5 }, result));

		result = ArrayTools.move(array, 0, 5);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new int[] { 5, 0, 1, 3, 4, 2 }, result));

		result = ArrayTools.move(array, 2, 4);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new int[] { 5, 0, 4, 1, 3, 2 }, result));

		result = ArrayTools.move(array, 2, 2);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new int[] { 5, 0, 4, 1, 3, 2 }, result));
	}

	public void testMoveIntArrayIntIntInt() {
		int[] array = new int[] { 0, 1, 2, 3, 4, 5 };

		int[] result = ArrayTools.move(array, 4, 2, 1);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new int[] { 0, 1, 3, 4, 2, 5 }, result));

		result = ArrayTools.move(array, 0, 5, 1);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new int[] { 5, 0, 1, 3, 4, 2 }, result));

		result = ArrayTools.move(array, 2, 4, 1);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new int[] { 5, 0, 4, 1, 3, 2 }, result));

		result = ArrayTools.move(array, 2, 4, 2);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new int[] { 5, 0, 3, 2, 4, 1 }, result));

		result = ArrayTools.move(array, 0, 1, 4);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new int[] { 0, 3, 2, 4, 5, 1 }, result));

		result = ArrayTools.move(array, 1, 0, 4);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new int[] { 5, 0, 3, 2, 4, 1 }, result));

		result = ArrayTools.move(array, 1, 1, 4);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new int[] { 5, 0, 3, 2, 4, 1 }, result));

		result = ArrayTools.move(array, 1, 0, 0);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new int[] { 5, 0, 3, 2, 4, 1 }, result));
	}

	public void testMoveCharArrayIntInt() {
		char[] array = new char[] { 'a', 'b', 'c', 'd', 'e', 'f' };

		char[] result = ArrayTools.move(array, 4, 2);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new char[] { 'a', 'b', 'd', 'e', 'c', 'f' }, result));

		result = ArrayTools.move(array, 0, 5);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new char[] { 'f', 'a', 'b', 'd', 'e', 'c' }, result));

		result = ArrayTools.move(array, 2, 4);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new char[] { 'f', 'a', 'e', 'b', 'd', 'c' }, result));

		result = ArrayTools.move(array, 2, 2);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new char[] { 'f', 'a', 'e', 'b', 'd', 'c' }, result));
	}

	public void testMoveCharArrayIntIntInt() {
		char[] array = new char[] { 'a', 'b', 'b', 'c', 'd', 'e' };

		char[] result = ArrayTools.move(array, 4, 2, 1);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new char[] { 'a', 'b', 'c', 'd', 'b', 'e' }, result));

		result = ArrayTools.move(array, 0, 5, 1);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new char[] { 'e', 'a', 'b', 'c', 'd', 'b' }, result));

		result = ArrayTools.move(array, 2, 4, 1);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new char[] { 'e', 'a', 'd', 'b', 'c', 'b' }, result));

		result = ArrayTools.move(array, 2, 4, 2);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new char[] { 'e', 'a', 'c', 'b', 'd', 'b' }, result));

		result = ArrayTools.move(array, 0, 1, 4);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new char[] { 'a', 'c', 'b', 'd', 'e', 'b' }, result));

		result = ArrayTools.move(array, 1, 0, 4);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new char[] { 'e', 'a', 'c', 'b', 'd', 'b' }, result));

		result = ArrayTools.move(array, 1, 1, 4);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new char[] { 'e', 'a', 'c', 'b', 'd', 'b' }, result));

		result = ArrayTools.move(array, 1, 0, 0);
		assertSame(array, result);  // the array is modified in place and returned
		assertTrue(Arrays.equals(new char[] { 'e', 'a', 'c', 'b', 'd', 'b' }, result));
	}


	// ********** remove **********

	public void testRemoveObjectArrayObject_Object() {
		Object[] a = this.buildObjectArray1();
		a = ArrayTools.add(a, "three");
		a = ArrayTools.add(a, "four");
		a = ArrayTools.add(a, "five");

		assertEquals(6, a.length);
		assertTrue(ArrayTools.contains(a, "three"));
		a = ArrayTools.remove(a, "three");
		assertEquals(5, a.length);
		assertFalse(ArrayTools.contains(a, "three"));
		assertTrue(ArrayTools.contains(a, "four"));
		assertTrue(ArrayTools.contains(a, "five"));
	}

	public void testRemoveObjectArrayObject_String() {
		String[] a = this.buildStringArray1();
		a = ArrayTools.add(a, "three");
		a = ArrayTools.add(a, "four");
		a = ArrayTools.add(a, "five");

		assertEquals(6, a.length);
		assertTrue(ArrayTools.contains(a, "three"));
		a = ArrayTools.remove(a, "three");
		assertEquals(5, a.length);
		assertFalse(ArrayTools.contains(a, "three"));
		assertTrue(ArrayTools.contains(a, "four"));
		assertTrue(ArrayTools.contains(a, "five"));
	}

	public void testRemoveCharArrayChar() {
		char[] a = this.buildCharArray();
		a = ArrayTools.add(a, 'd');
		a = ArrayTools.add(a, 'e');
		a = ArrayTools.add(a, 'f');

		assertEquals(6, a.length);
		assertTrue(ArrayTools.contains(a, 'd'));
		a = ArrayTools.remove(a, 'd');
		assertEquals(5, a.length);
		assertFalse(ArrayTools.contains(a, 'd'));
		assertTrue(ArrayTools.contains(a, 'e'));
		assertTrue(ArrayTools.contains(a, 'f'));
	}

	public void testRemoveIntArrayInt() {
		int[] a = this.buildIntArray();
		a = ArrayTools.add(a, 30);
		a = ArrayTools.add(a, 40);
		a = ArrayTools.add(a, 50);

		assertEquals(6, a.length);
		assertTrue(ArrayTools.contains(a, 30));
		a = ArrayTools.remove(a, 30);
		assertEquals(5, a.length);
		assertFalse(ArrayTools.contains(a, 30));
		assertTrue(ArrayTools.contains(a, 40));
		assertTrue(ArrayTools.contains(a, 50));
	}


	// ********** remove all **********

	public void testRemoveAllObjectArrayObjectArray() {
		String[] a1 = new String[] { "A", "A", "B", "B", "C", "C", "D", "D", "E", "E", "F", "F" };
		String[] a2 = new String[] { "E", "B" };
		String[] a3 = ArrayTools.removeAll(a1, (Object[]) a2);
		assertTrue(Arrays.equals(new String[] { "A", "A", "C", "C", "D", "D", "F", "F" }, a3));
	}

	public void testRemoveAllObjectArrayObjectArray_Empty() {
		String[] a1 = new String[] { "A", "A", "B", "B", "C", "C", "D", "D", "E", "E", "F", "F" };
		String[] a2 = new String[0];
		String[] a3 = ArrayTools.removeAll(a1, (Object[]) a2);
		assertTrue(Arrays.equals(a1, a3));
	}

	public void testRemoveAllObjectArrayObjectArray_NoMatches() {
		String[] a1 = new String[] { "A", "A", "B", "B", "C", "C", "D", "D", "E", "E", "F", "F" };
		String[] a2 = new String[] { "X", "Y", "Z" };
		String[] a3 = ArrayTools.removeAll(a1, (Object[]) a2);
		assertTrue(Arrays.equals(a1, a3));
	}

	public void testRemoveAllObjectArrayIterable() {
		String[] a1 = new String[] { "A", "A", "B", "B", "C", "C", "D", "D", "E", "E", "F", "F" };
		Iterable<?> iterable = Arrays.asList(new String[] { "E", "B" });
		String[] a3 = ArrayTools.removeAll(a1, iterable);
		assertTrue(Arrays.equals(new String[] { "A", "A", "C", "C", "D", "D", "F", "F" }, a3));
	}

	public void testRemoveAllObjectArrayIterableInt() {
		String[] a1 = new String[] { "A", "A", "B", "B", "C", "C", "D", "D", "E", "E", "F", "F" };
		Iterable<?> iterable = Arrays.asList(new String[] { "E", "B" });
		String[] a3 = ArrayTools.removeAll(a1, iterable, 7);
		assertTrue(Arrays.equals(new String[] { "A", "A", "C", "C", "D", "D", "F", "F" }, a3));
	}

	public void testRemoveAllObjectArrayIterator() {
		String[] a1 = new String[] { "A", "A", "B", "B", "C", "C", "D", "D", "E", "E", "F", "F" };
		Iterable<?> iterable = Arrays.asList(new String[] { "E", "B" });
		String[] a3 = ArrayTools.removeAll(a1, iterable.iterator());
		assertTrue(Arrays.equals(new String[] { "A", "A", "C", "C", "D", "D", "F", "F" }, a3));
	}

	public void testRemoveAllObjectArrayIterator_Empty() {
		String[] a1 = new String[] { "A", "A", "B", "B", "C", "C", "D", "D", "E", "E", "F", "F" };
		String[] a3 = ArrayTools.removeAll(a1, EmptyIterator.instance());
		assertTrue(Arrays.equals(a1, a3));
	}

	public void testRemoveAllObjectArrayIteratorInt() {
		String[] a1 = new String[] { "A", "A", "B", "B", "C", "C", "D", "D", "E", "E", "F", "F" };
		Iterable<?> iterable = Arrays.asList(new String[] { "E", "B" });
		String[] a3 = ArrayTools.removeAll(a1, iterable.iterator(), 7);
		assertTrue(Arrays.equals(new String[] { "A", "A", "C", "C", "D", "D", "F", "F" }, a3));
	}

	public void testRemoveAllObjectArrayIteratorInt_Empty() {
		String[] a1 = new String[] { "A", "A", "B", "B", "C", "C", "D", "D", "E", "E", "F", "F" };
		String[] a3 = ArrayTools.removeAll(a1, EmptyIterator.instance(), 7);
		assertTrue(Arrays.equals(a1, a3));
	}

	public void testRemoveAllObjectArrayCollection() {
		String[] a1 = new String[] { "A", "A", "B", "B", "C", "C", "D", "D", "E", "E", "F", "F" };
		Collection<String> collection = Arrays.asList(new String[] { "E", "B" });
		String[] a3 = ArrayTools.removeAll(a1, collection);
		assertTrue(Arrays.equals(new String[] { "A", "A", "C", "C", "D", "D", "F", "F" }, a3));
	}

	public void testRemoveAllObjectArrayCollection_Empty() {
		String[] a1 = new String[] { "A", "A", "B", "B", "C", "C", "D", "D", "E", "E", "F", "F" };
		Collection<String> collection = new ArrayList<String>();
		String[] a3 = ArrayTools.removeAll(a1, collection);
		assertTrue(Arrays.equals(a1, a3));
	}

	public void testRemoveAllObjectArrayCollection_EmptyArray() {
		String[] a1 = new String[0];
		Collection<String> collection = Arrays.asList(new String[] { "E", "B" });
		String[] a3 = ArrayTools.removeAll(a1, collection);
		assertTrue(Arrays.equals(a1, a3));
		assertEquals(0, a3.length);
	}

	public void testRemoveAllObjectArrayCollection_NoMatches() {
		String[] a1 = new String[] { "A", "A", "B", "B", "C", "C", "D", "D", "E", "E", "F", "F" };
		Collection<String> collection = Arrays.asList(new String[] { "X", "Y", "Z" });
		String[] a3 = ArrayTools.removeAll(a1, collection);
		assertTrue(Arrays.equals(a1, a3));
	}

	public void testRemoveAllCharArrayCharArray() {
		char[] a1 = new char[] { 'A', 'A', 'B', 'B', 'C', 'C', 'D', 'D', 'E', 'E', 'F', 'F' };
		char[] a2 = new char[] { 'E', 'B' };
		assertTrue(Arrays.equals(new char[] { 'A', 'A', 'C', 'C', 'D', 'D', 'F', 'F' }, ArrayTools.removeAll(a1, a2)));
	}

	public void testRemoveAllCharArrayCharArray_Empty1() {
		char[] a1 = new char[0];
		char[] a2 = new char[] { 'E', 'B' };
		assertTrue(Arrays.equals(a1, ArrayTools.removeAll(a1, a2)));
	}

	public void testRemoveAllCharArrayCharArray_Empty2() {
		char[] a1 = new char[] { 'A', 'A', 'B', 'B', 'C', 'C', 'D', 'D', 'E', 'E', 'F', 'F' };
		char[] a2 = new char[0];
		assertTrue(Arrays.equals(a1, ArrayTools.removeAll(a1, a2)));
	}

	public void testRemoveAllCharArrayCharArray_NoMatches() {
		char[] a1 = new char[] { 'A', 'A', 'B', 'B', 'C', 'C', 'D', 'D', 'E', 'E', 'F', 'F' };
		char[] a2 = new char[] { 'X', 'Z' };
		assertTrue(Arrays.equals(a1, ArrayTools.removeAll(a1, a2)));
	}

	public void testRemoveAllIntArrayIntArray() {
		int[] a1 = new int[] { 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6 };
		int[] a2 = new int[] { 5, 2 };
		assertTrue(Arrays.equals(new int[] { 1, 1, 3, 3, 4, 4, 6, 6 }, ArrayTools.removeAll(a1, a2)));
	}

	public void testRemoveAllIntArrayIntArray_Empty1() {
		int[] a1 = new int[0];
		int[] a2 = new int[] { 5, 2 };
		assertTrue(Arrays.equals(a1, ArrayTools.removeAll(a1, a2)));
	}

	public void testRemoveAllIntArrayIntArray_Empty2() {
		int[] a1 = new int[] { 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6 };
		int[] a2 = new int[0];
		assertTrue(Arrays.equals(a1, ArrayTools.removeAll(a1, a2)));
	}

	public void testRemoveAllIntArrayIntArray_NoMatches() {
		int[] a1 = new int[] { 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6 };
		int[] a2 = new int[] { 52, 67 };
		assertTrue(Arrays.equals(a1, ArrayTools.removeAll(a1, a2)));
	}


	// ********** remove all occurrences **********

	public void testRemoveAllOccurrencesObjectArrayObject() {
		String[] a = this.buildStringArray1();
		assertEquals(3, a.length);
		a = ArrayTools.removeAllOccurrences(a, "three");
		assertEquals(3, a.length);
		a = ArrayTools.removeAllOccurrences(a, "two");
		assertEquals(2, a.length);
		a = ArrayTools.removeAllOccurrences(a, "two");
		assertEquals(2, a.length);

		a = ArrayTools.add(a, "five");
		a = ArrayTools.add(a, "five");
		a = ArrayTools.add(a, "five");
		assertEquals(5, a.length);
		a = ArrayTools.removeAllOccurrences(a, "five");
		assertEquals(2, a.length);
		a = ArrayTools.removeAllOccurrences(a, "five");
		assertEquals(2, a.length);

		a = ArrayTools.add(a, null);
		a = ArrayTools.add(a, null);
		a = ArrayTools.add(a, null);
		assertEquals(5, a.length);
		a = ArrayTools.removeAllOccurrences(a, null);
		assertEquals(2, a.length);
		a = ArrayTools.removeAllOccurrences(a, null);
		assertEquals(2, a.length);
	}

	public void testRemoveAllOccurrencesObjectArrayObject_Empty() {
		String[] a = new String[0];
		a = ArrayTools.removeAllOccurrences(a, "three");
		assertEquals(0, a.length);
	}

	public void testRemoveAllOccurrencesCharArrayChar() {
		char[] a = this.buildCharArray();
		assertEquals(3, a.length);
		a = ArrayTools.removeAllOccurrences(a, 'd');
		assertEquals(3, a.length);
		a = ArrayTools.removeAllOccurrences(a, 'b');
		assertEquals(2, a.length);
		a = ArrayTools.removeAllOccurrences(a, 'b');
		assertEquals(2, a.length);

		a = ArrayTools.add(a, 'g');
		a = ArrayTools.add(a, 'g');
		a = ArrayTools.add(a, 'g');
		assertEquals(5, a.length);
		a = ArrayTools.removeAllOccurrences(a, 'g');
		assertEquals(2, a.length);
		a = ArrayTools.removeAllOccurrences(a, 'g');
		assertEquals(2, a.length);
	}

	public void testRemoveAllOccurrencesCharArrayChar_Empty() {
		char[] a = new char[0];
		a = ArrayTools.removeAllOccurrences(a, 'a');
		assertEquals(0, a.length);
	}

	public void testRemoveAllOccurrencesIntArrayInt() {
		int[] a = this.buildIntArray();
		assertEquals(3, a.length);
		a = ArrayTools.removeAllOccurrences(a, 55);
		assertEquals(3, a.length);
		a = ArrayTools.removeAllOccurrences(a, 10);
		assertEquals(2, a.length);
		a = ArrayTools.removeAllOccurrences(a, 10);
		assertEquals(2, a.length);

		a = ArrayTools.add(a, 77);
		a = ArrayTools.add(a, 77);
		a = ArrayTools.add(a, 77);
		assertEquals(5, a.length);
		a = ArrayTools.removeAllOccurrences(a, 77);
		assertEquals(2, a.length);
		a = ArrayTools.removeAllOccurrences(a, 77);
		assertEquals(2, a.length);
	}

	public void testRemoveAllOccurrencesIntArrayInt_Empty() {
		int[] a = new int[0];
		a = ArrayTools.removeAllOccurrences(a, 22);
		assertEquals(0, a.length);
	}


	// ********** remove duplicate elements **********

	public void testRemoveDuplicateElementsObjectArray() {
		List<String> list = this.buildStringVector1();
		list.add("zero");
		list.add("zero");
		list.add("two");
		list.add("zero");
		String[] array = ArrayTools.removeDuplicateElements(list.toArray(new String[list.size()]));
		int i = 0;
		assertEquals("zero", array[i++]);
		assertEquals("one", array[i++]);
		assertEquals("two", array[i++]);
		assertEquals(i, array.length);
	}

	public void testRemoveDuplicateElementsObjectArray_Empty() {
		String[] array = ArrayTools.removeDuplicateElements(new String[0]);
		assertEquals(0, array.length);
	}

	public void testRemoveDuplicateElementsObjectArray_SingleElement() {
		String[] array = ArrayTools.removeDuplicateElements(new String[] { "foo" });
		assertEquals(1, array.length);
	}

	public void testRemoveDuplicateElementsObjectArray_NoDuplicates() {
		String[] a1 = new String[] { "foo", "bar", "baz" };
		String[] a2 = ArrayTools.removeDuplicateElements(a1);
		assertEquals(3, a2.length);
		assertTrue(Arrays.equals(a1, a2));
	}


	// ********** remove element at index **********

	public void testRemoveElementAtIndexObjectArrayInt() {
		String[] a = new String[] { "A", "B", "A", "C", "A", "D" };
		a = ArrayTools.removeElementAtIndex(a, 3);
		assertTrue(Arrays.equals(new String[] { "A", "B", "A", "A", "D" }, a));
	}

	public void testRemoveElementAtIndexCharArrayInt() {
		char[] a = new char[] { 'A', 'B', 'A', 'C', 'A', 'D' };
		a = ArrayTools.removeElementAtIndex(a, 3);
		assertTrue(Arrays.equals(new char[] { 'A', 'B', 'A', 'A', 'D' }, a));
	}

	public void testRemoveElementAtIndexIntArrayInt() {
		int[] a = new int[] { 8, 6, 7, 33, 2, 11 };
		a = ArrayTools.removeElementsAtIndex(a, 3, 3);
		assertTrue(Arrays.equals(new int[] { 8, 6, 7 }, a));
	}

	public void testRemoveFirstObjectArray() {
		String[] a = new String[] { "A", "B", "A", "C", "A", "D" };
		a = ArrayTools.removeFirst(a);
		assertTrue(Arrays.equals(new String[] { "B", "A", "C", "A", "D" }, a));
	}

	public void testRemoveFirstCharArray() {
		char[] a = new char[] { 'A', 'B', 'A', 'C', 'A', 'D' };
		a = ArrayTools.removeFirst(a);
		assertTrue(Arrays.equals(new char[] { 'B', 'A', 'C', 'A', 'D' }, a));
	}

	public void testRemoveFirstIntArray() {
		int[] a = new int[] { 8, 6, 7, 33, 2, 11 };
		a = ArrayTools.removeFirst(a);
		assertTrue(Arrays.equals(new int[] { 6, 7, 33, 2, 11 }, a));
	}

	public void testRemoveLastObjectArray() {
		String[] a = new String[] { "A", "B", "A", "C", "A", "D" };
		a = ArrayTools.removeLast(a);
		assertTrue(Arrays.equals(new String[] { "A", "B", "A", "C", "A" }, a));
	}

	public void testRemoveLastCharArray() {
		char[] a = new char[] { 'A', 'B', 'A', 'C', 'A', 'D' };
		a = ArrayTools.removeLast(a);
		assertTrue(Arrays.equals(new char[] { 'A', 'B', 'A', 'C', 'A' }, a));
	}

	public void testRemoveLastIntArray() {
		int[] a = new int[] { 8, 6, 7, 33, 2, 11 };
		a = ArrayTools.removeLast(a);
		assertTrue(Arrays.equals(new int[] { 8, 6, 7, 33, 2 }, a));
	}


	// ********** remove elements at index **********

	public void testRemoveElementsAtIndexObjectArrayIntInt() {
		String[] a = new String[] { "A", "B", "A", "C", "A", "D" };
		a = ArrayTools.removeElementsAtIndex(a, 3, 2);
		assertTrue(Arrays.equals(new String[] { "A", "B", "A", "D" }, a));
	}

	public void testRemoveElementsAtIndexObjectArrayIntInt_ZeroLength() {
		String[] a1 = new String[] { "A", "B", "A", "C", "A", "D" };
		String[] a2 = ArrayTools.removeElementsAtIndex(a1, 3, 0);
		assertTrue(Arrays.equals(a1, a2));
	}

	public void testRemoveElementsAtIndexObjectArrayIntInt_Empty() {
		String[] a = new String[] { "A", "B", "A", "C", "A", "D" };
		a = ArrayTools.removeElementsAtIndex(a, 0, 6);
		assertEquals(0, a.length);
	}

	public void testRemoveElementsAtIndexCharArrayIntInt() {
		char[] a = new char[] { 'A', 'B', 'A', 'C', 'A', 'D' };
		a = ArrayTools.removeElementsAtIndex(a, 0, 5);
		assertTrue(Arrays.equals(new char[] { 'D' }, a));
	}

	public void testRemoveElementsAtIndexCharArrayIntInt_ZeroLength() {
		char[] a1 = new char[] { 'A', 'B', 'A', 'C', 'A', 'D' };
		char[] a2 = ArrayTools.removeElementsAtIndex(a1, 3, 0);
		assertTrue(Arrays.equals(a1, a2));
	}

	public void testRemoveElementsAtIndexCharArrayIntInt_Empty() {
		char[] a = new char[] { 'A', 'B', 'A', 'C', 'A', 'D' };
		a = ArrayTools.removeElementsAtIndex(a, 0, 6);
		assertEquals(0, a.length);
	}

	public void testRemoveElementsAtIndexIntArrayIntInt() {
		int[] a = new int[] { 8, 6, 7, 33, 2, 11 };
		a = ArrayTools.removeElementsAtIndex(a, 3, 3);
		assertTrue(Arrays.equals(new int[] { 8, 6, 7 }, a));
	}

	public void testRemoveElementsAtIndexIntArrayIntInt_ZeroLength() {
		int[] a1 = new int[] { 8, 6, 7, 33, 2, 11 };
		int[] a2 = ArrayTools.removeElementsAtIndex(a1, 3, 0);
		assertTrue(Arrays.equals(a1, a2));
	}

	public void testRemoveElementsAtIndexIntArrayIntInt_Empty() {
		int[] a = new int[] { 8, 6, 7, 33, 2, 11 };
		a = ArrayTools.removeElementsAtIndex(a, 0, 6);
		assertEquals(0, a.length);
	}


	// ********** replace all **********

	public void testReplaceAllObjectArrayObjectObject_Object() {
		Object[] a = new Object[] { "A", "B", "A", "C", "A", "D" };
		a = ArrayTools.replaceAll(a, "A", "Z");
		assertTrue(Arrays.equals(new Object[] { "Z", "B", "Z", "C", "Z", "D" }, a));
	}

	public void testReplaceAllObjectArrayObjectObject_String() {
		String[] a = new String[] { "A", "B", "A", "C", "A", "D" };
		a = ArrayTools.replaceAll(a, "A", "Z");
		assertTrue(Arrays.equals(new String[] { "Z", "B", "Z", "C", "Z", "D" }, a));
	}

	public void testReplaceAllObjectArrayObjectObject_Null() {
		String[] a = new String[] { null, "B", null, "C", null, "D" };
		a = ArrayTools.replaceAll(a, null, "Z");
		assertTrue(Arrays.equals(new String[] { "Z", "B", "Z", "C", "Z", "D" }, a));
	}

	public void testReplaceAllCharArrayCharChar() {
		char[] a = new char[] { 'A', 'B', 'A', 'C', 'A', 'D' };
		a = ArrayTools.replaceAll(a, 'A', 'Z');
		assertTrue(Arrays.equals(new char[] { 'Z', 'B', 'Z', 'C', 'Z', 'D' }, a));
	}

	public void testReplaceAllIntArrayIntInt() {
		int[] a = new int[] { 0, 1, 0, 7, 0, 99 };
		a = ArrayTools.replaceAll(a, 0, 13);
		assertTrue(Arrays.equals(new int[] { 13, 1, 13, 7, 13, 99 }, a));
	}


	// ********** retain all **********

	public void testRetainAllObjectArrayObjectArray() {
		String[] a1 = new String[] { "A", "A", "B", "B", "C", "C", "D", "D", "E", "E", "F", "F" };
		Object[] a2 = new Object[] { "E", "B", new Integer(7) };
		assertTrue(Arrays.equals(new String[] { "B", "B", "E", "E" }, ArrayTools.retainAll(a1, a2)));
	}

	public void testRetainAllObjectArrayObjectArray_EmptyObjectArray1() {
		String[] a1 = new String[0];
		String[] a2 = new String[] { "E", "B", "" };
		String[] a3 = ArrayTools.retainAll(a1, a2);
		assertEquals(0, a3.length);
	}

	public void testRetainAllObjectArrayObjectArray_EmptyObjectArray2() {
		String[] a1 = new String[] { "E", "B", "" };
		String[] a2 = new String[0];
		String[] a3 = ArrayTools.retainAll(a1, a2);
		assertEquals(0, a3.length);
	}

	public void testRetainAllObjectArrayObjectArray_BothEmpty() {
		String[] a1 = new String[0];
		String[] a2 = new String[0];
		String[] a3 = ArrayTools.retainAll(a1, a2);
		assertEquals(0, a3.length);
	}

	public void testRetainAllObjectArrayIterable() {
		String[] a1 = new String[] { "A", "A", "B", "B", "C", "C", "D", "D", "E", "E", "F", "F" };
		Iterable<String> iterable = Arrays.asList(new String[] { "E", "B", "" });
		assertTrue(Arrays.equals(new String[] { "B", "B", "E", "E" }, ArrayTools.retainAll(a1, iterable)));
	}

	public void testRetainAllObjectArrayIterable_EmptyObjectArray() {
		String[] a1 = new String[0];
		Iterable<String> iterable = Arrays.asList(new String[] { "E", "B", "" });
		String[] a3 = ArrayTools.retainAll(a1, iterable);
		assertEquals(0, a3.length);
	}

	public void testRetainAllObjectArrayIterableInt() {
		String[] a1 = new String[] { "A", "A", "B", "B", "C", "C", "D", "D", "E", "E", "F", "F" };
		Iterable<String> iterable = Arrays.asList(new String[] { "E", "B", "" });
		assertTrue(Arrays.equals(new String[] { "B", "B", "E", "E" }, ArrayTools.retainAll(a1, iterable, 3)));
	}

	public void testRetainAllObjectArrayIterableInt_EmptyObjectArray() {
		String[] a1 = new String[0];
		Iterable<String> iterable = Arrays.asList(new String[] { "E", "B", "" });
		String[] a3 = ArrayTools.retainAll(a1, iterable, 3);
		assertEquals(0, a3.length);
	}

	public void testRetainAllObjectArrayIterator() {
		String[] a1 = new String[] { "A", "A", "B", "B", "C", "C", "D", "D", "E", "E", "F", "F" };
		Iterator<String> iterator = Arrays.asList(new String[] { "E", "B", "" }).iterator();
		assertTrue(Arrays.equals(new String[] { "B", "B", "E", "E" }, ArrayTools.retainAll(a1, iterator)));
	}

	public void testRetainAllObjectArrayIterator_EmptyObjectArray() {
		String[] a1 = new String[0];
		Iterator<String> iterator = Arrays.asList(new String[] { "E", "B", "" }).iterator();
		String[] a3 = ArrayTools.retainAll(a1, iterator);
		assertEquals(0, a3.length);
	}

	public void testRetainAllObjectArrayIterator_EmptyIterator() {
		String[] a1 = new String[] { "A", "A", "B", "B", "C", "C", "D", "D", "E", "E", "F", "F" };
		assertTrue(Arrays.equals(new String[0], ArrayTools.retainAll(a1, EmptyIterator.instance())));
	}

	public void testRetainAllObjectArrayIteratorInt() {
		String[] a1 = new String[] { "A", "A", "B", "B", "C", "C", "D", "D", "E", "E", "F", "F" };
		Iterator<String> iterator = Arrays.asList(new String[] { "E", "B", "" }).iterator();
		assertTrue(Arrays.equals(new String[] { "B", "B", "E", "E" }, ArrayTools.retainAll(a1, iterator, 3)));
	}

	public void testRetainAllObjectArrayIteratorInt_EmptyIterator() {
		String[] a1 = new String[] { "A", "A", "B", "B", "C", "C", "D", "D", "E", "E", "F", "F" };
		assertTrue(Arrays.equals(new String[0], ArrayTools.retainAll(a1, EmptyIterator.instance(), 3)));
	}

	public void testRetainAllObjectArrayIteratorInt_EmptyObjectArray() {
		String[] a1 = new String[0];
		Iterator<String> iterator = Arrays.asList(new String[] { "E", "B", "" }).iterator();
		String[] a3 = ArrayTools.retainAll(a1, iterator, 3);
		assertEquals(0, a3.length);
	}

	public void testRetainAllObjectArrayCollection() {
		String[] a1 = new String[] { "A", "A", "B", "B", "C", "C", "D", "D", "E", "E", "F", "F" };
		Collection<String> collection = Arrays.asList(new String[] { "E", "B", "" });
		assertTrue(Arrays.equals(new String[] { "B", "B", "E", "E" }, ArrayTools.retainAll(a1, collection)));
	}

	public void testRetainAllObjectArrayCollection_EmptyObjectArray() {
		String[] a1 = new String[0];
		Collection<String> collection = Arrays.asList(new String[] { "E", "B", "" });
		String[] a3 = ArrayTools.retainAll(a1, collection);
		assertEquals(0, a3.length);
	}

	public void testRetainAllObjectArrayCollection_EmptyCollection() {
		String[] a1 = new String[] { "A", "A", "B", "B", "C", "C", "D", "D", "E", "E", "F", "F" };
		Collection<String> collection = new ArrayList<String>();
		String[] a3 = ArrayTools.retainAll(a1, collection);
		assertEquals(0, a3.length);
	}

	public void testRetainAllObjectArrayCollection_All() {
		String[] a1 = new String[] { "A", "A", "B", "B", "C", "C", "D", "D", "E", "E", "F", "F" };
		Collection<String> collection = Arrays.asList(new String[] { "A", "B", "C", "D", "E", "F" });
		assertTrue(Arrays.equals(a1, ArrayTools.retainAll(a1, collection)));
	}

	public void testRetainAllCharArrayCharArray() {
		char[] a1 = new char[] { 'A', 'A', 'B', 'B', 'C', 'C', 'D', 'D', 'E', 'E', 'F', 'F' };
		char[] a2 = new char[] { 'E', 'B' };
		assertTrue(Arrays.equals(new char[] { 'B', 'B', 'E', 'E' }, ArrayTools.retainAll(a1, a2)));
	}

	public void testRetainAllCharArrayCharArray_EmptyCharArray1() {
		char[] a1 = new char[0];
		char[] a2 = new char[] { 'E', 'B' };
		assertSame(a1, ArrayTools.retainAll(a1, a2));
	}

	public void testRetainAllCharArrayCharArray_EmptyCharArray2() {
		char[] a1 = new char[] { 'E', 'B' };
		char[] a2 = new char[0];
		assertEquals(0, ArrayTools.retainAll(a1, a2).length);
	}

	public void testRetainAllCharArrayCharArray_RetainAll() {
		char[] a1 = new char[] { 'E', 'B', 'E', 'B', 'E', 'B', 'E', 'B', 'E' };
		char[] a2 = new char[] { 'E', 'B' };
		assertSame(a1, ArrayTools.retainAll(a1, a2));
	}

	public void testRetainAllIntArrayIntArray() {
		int[] a1 = new int[] { 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6 };
		int[] a2 = new int[] { 5, 2 };
		assertTrue(Arrays.equals(new int[] { 2, 2, 5, 5 }, ArrayTools.retainAll(a1, a2)));
	}

	public void testRetainAllIntArrayIntArray_EmptyIntArray1() {
		int[] a1 = new int[0];
		int[] a2 = new int[] { 5, 2 };
		assertSame(a1, ArrayTools.retainAll(a1, a2));
	}

	public void testRetainAllIntArrayIntArray_EmptyIntArray2() {
		int[] a1 = new int[] { 5, 2 };
		int[] a2 = new int[0];
		assertEquals(0, ArrayTools.retainAll(a1, a2).length);
	}

	public void testRetainAllIntArrayIntArray_RetainAll() {
		int[] a1 = new int[] { 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5 };
		int[] a2 = new int[] { 5, 2 };
		assertSame(a1, ArrayTools.retainAll(a1, a2));
	}


	// ********** reverse **********

	public void testReverseObjectArray_Object() {
		Object[] a = this.buildObjectArray1();
		a = ArrayTools.reverse(a);
		assertEquals("two", a[0]);
		assertEquals("one", a[1]);
		assertEquals("zero", a[2]);
	}

	public void testReverseObjectArray_String() {
		String[] a = this.buildStringArray1();
		a = ArrayTools.reverse(a);
		assertEquals("two", a[0]);
		assertEquals("one", a[1]);
		assertEquals("zero", a[2]);
	}

	public void testReverseObjectArray_Singleton() {
		String[] a1 = new String[] { "foo" };
		String[] a2 = ArrayTools.reverse(a1);
		assertTrue(Arrays.equals(a1, a2));
	}

	public void testReverseCharArray() {
		char[] a = this.buildCharArray();
		a = ArrayTools.reverse(a);
		assertEquals('c', a[0]);
		assertEquals('b', a[1]);
		assertEquals('a', a[2]);
	}

	public void testReverseCharArray_Singleton() {
		char[] a1 = new char[] { 'f' };
		char[] a2 = ArrayTools.reverse(a1);
		assertTrue(Arrays.equals(a1, a2));
	}

	public void testReverseIntArray() {
		int[] a = this.buildIntArray();
		a = ArrayTools.reverse(a);
		assertEquals(20, a[0]);
		assertEquals(10, a[1]);
		assertEquals(0, a[2]);
	}

	public void testReverseIntArray_Singleton() {
		int[] a1 = new int[] { 7 };
		int[] a2 = ArrayTools.reverse(a1);
		assertTrue(Arrays.equals(a1, a2));
	}


	// ********** rotate **********

	public void testRotateObjectArray() {
		String[] a = this.buildStringArray1();
		a = ArrayTools.rotate(a);
		assertEquals("two", a[0]);
		assertEquals("zero", a[1]);
		assertEquals("one", a[2]);
	}

	public void testRotateObjectArray_Zero() {
		String[] a1 = new String[0];
		String[] a2 = ArrayTools.rotate(a1);
		assertSame(a1, a2);
	}

	public void testRotateObjectArray_One() {
		String[] a1 = new String[] { "foo  " };
		String[] a2 = ArrayTools.rotate(a1);
		assertSame(a1, a2);
	}

	public void testRotateObjectArrayInt() {
		String[] a = this.buildStringArray1();
		a = ArrayTools.rotate(a, 2);
		assertEquals("one", a[0]);
		assertEquals("two", a[1]);
		assertEquals("zero", a[2]);
	}

	public void testRotateObjectArrayInt_ZeroDistance() {
		String[] a1 = this.buildStringArray1();
		String[] a2 = ArrayTools.rotate(a1, 0);
		assertSame(a1, a2);
	}

	public void testRotateObjectArrayInt_NegativeDistance() {
		String[] a1 = this.buildStringArray1();
		String[] a2 = ArrayTools.rotate(a1, -1);
		assertEquals("one", a2[0]);
		assertEquals("two", a2[1]);
		assertEquals("zero", a2[2]);
	}

	public void testRotateObjectArrayInt_Zero() {
		String[] a1 = new String[0];
		String[] a2 = ArrayTools.rotate(a1, 7);
		assertSame(a1, a2);
	}

	public void testRotateObjectArrayInt_One() {
		String[] a1 = new String[] { "foo  " };
		String[] a2 = ArrayTools.rotate(a1, 8);
		assertSame(a1, a2);
	}

	public void testRotateCharArray() {
		char[] a = this.buildCharArray();
		a = ArrayTools.rotate(a);
		assertEquals('c', a[0]);
		assertEquals('a', a[1]);
		assertEquals('b', a[2]);
	}

	public void testRotateCharArray_Zero() {
		char[] a1 = new char[0];
		char[] a2 = ArrayTools.rotate(a1);
		assertSame(a1, a2);
	}

	public void testRotateCharArray_One() {
		char[] a1 = new char[] { 'a' };
		char[] a2 = ArrayTools.rotate(a1);
		assertSame(a1, a2);
	}

	public void testRotateCharArrayInt() {
		char[] a = this.buildCharArray();
		a = ArrayTools.rotate(a, 2);
		assertEquals('b', a[0]);
		assertEquals('c', a[1]);
		assertEquals('a', a[2]);
	}

	public void testRotateCharArrayInt_ZeroDistance() {
		char[] a1 = new char[] { 'a', 'b', 'c' };
		char[] a2 = ArrayTools.rotate(a1, 0);
		assertSame(a1, a2);
	}

	public void testRotateCharArrayInt_NegativeDistance() {
		char[] a = this.buildCharArray();
		a = ArrayTools.rotate(a, -1);
		assertEquals('b', a[0]);
		assertEquals('c', a[1]);
		assertEquals('a', a[2]);
	}

	public void testRotateCharArrayInt_Zero() {
		char[] a1 = new char[0];
		char[] a2 = ArrayTools.rotate(a1, 2001);
		assertSame(a1, a2);
	}

	public void testRotateCharArrayInt_One() {
		char[] a1 = new char[] { 'a' };
		char[] a2 = ArrayTools.rotate(a1, 22);
		assertSame(a1, a2);
	}

	public void testRotateIntArray() {
		int[] a = this.buildIntArray();
		a = ArrayTools.rotate(a);
		assertEquals(20, a[0]);
		assertEquals(0, a[1]);
		assertEquals(10, a[2]);
	}

	public void testRotateIntArray_Zero() {
		int[] a1 = new int[0];
		int[] a2 = ArrayTools.rotate(a1);
		assertSame(a1, a2);
	}

	public void testRotateIntArray_One() {
		int[] a1 = new int[] { 77 };
		int[] a2 = ArrayTools.rotate(a1);
		assertSame(a1, a2);
	}

	public void testRotateIntArrayInt() {
		int[] a = this.buildIntArray();
		a = ArrayTools.rotate(a, 2);
		assertEquals(10, a[0]);
		assertEquals(20, a[1]);
		assertEquals(0, a[2]);
	}

	public void testRotateIntArrayInt_ZeroDistance() {
		int[] a1 = new int[] { 3, 2, 1 };
		int[] a2 = ArrayTools.rotate(a1, 0);
		assertSame(a1, a2);
	}

	public void testRotateIntArrayInt_NegativeDistance() {
		int[] a = this.buildIntArray();
		a = ArrayTools.rotate(a, -1);
		assertEquals(10, a[0]);
		assertEquals(20, a[1]);
		assertEquals(0, a[2]);
	}

	public void testRotateIntArrayInt_Zero() {
		int[] a1 = new int[0];
		int[] a2 = ArrayTools.rotate(a1, 3);
		assertSame(a1, a2);
	}

	public void testRotateIntArrayInt_One() {
		int[] a1 = new int[] { 77 };
		int[] a2 = ArrayTools.rotate(a1, 44);
		assertSame(a1, a2);
	}


	// ********** shuffle **********

	public void testShuffleObjectArray() {
		String[] array1 = this.buildStringArray1();
		String[] array2 = ArrayTools.shuffle(this.buildStringArray1());
		assertEquals(array1.length, array2.length);
		assertTrue(ArrayTools.containsAll(array1, (Object[]) array2));
	}

	public void testShuffleObjectArray_Singleton() {
		String[] array1 = new String[] { "foo" };
		String[] array2 = ArrayTools.shuffle(new String[] { "foo" });
		assertEquals(array1.length, array2.length);
		assertTrue(ArrayTools.containsAll(array1, (Object[]) array2));
	}

	public void testShuffleCharArray() {
		char[] array1 = this.buildCharArray();
		char[] array2 = ArrayTools.shuffle(this.buildCharArray());
		assertEquals(array1.length, array2.length);
		assertTrue(ArrayTools.containsAll(array1, array2));
	}

	public void testShuffleCharArray_Singleton() {
		char[] array1 = new char[] { 'f' };
		char[] array2 = ArrayTools.shuffle(new char[] { 'f' });
		assertEquals(array1.length, array2.length);
		assertTrue(ArrayTools.containsAll(array1, array2));
	}

	public void testShuffleIntArray() {
		int[] array1 = this.buildIntArray();
		int[] array2 = ArrayTools.shuffle(this.buildIntArray());
		assertEquals(array1.length, array2.length);
		assertTrue(ArrayTools.containsAll(array1, array2));
	}

	public void testShuffleIntArray_Singleton() {
		int[] array1 = new int[] { 7 };
		int[] array2 = ArrayTools.shuffle(new int[] { 7 });
		assertEquals(array1.length, array2.length);
		assertTrue(ArrayTools.containsAll(array1, array2));
	}


	// ********** sub-array **********

	public void testSubArrayObjectArrayIntInt() {
		String[] array = new String[] {"foo", "bar", "baz", "joo", "jar", "jaz"};
		String[] result = new String[] {"foo", "bar", "baz", "joo"};
		assertTrue(Arrays.equals(result, ArrayTools.subArray(array, 0, 4)));

		result = new String[] {"jar"};
		assertTrue(Arrays.equals(result, ArrayTools.subArray(array, 4, 5)));

		result = new String[0];
		assertTrue(Arrays.equals(result, ArrayTools.subArray(array, 5, 5)));

		result = new String[] {"joo", "jar", "jaz"};
		assertTrue(Arrays.equals(result, ArrayTools.subArray(array, 3, 6)));
	}

	public void testSubArrayIntArrayIntInt() {
		int[] array = new int[] {77, 99, 333, 4, 9090, 42};
		int[] result = new int[] {77, 99, 333, 4};
		assertTrue(Arrays.equals(result, ArrayTools.subArray(array, 0, 4)));

		result = new int[] {9090};
		assertTrue(Arrays.equals(result, ArrayTools.subArray(array, 4, 5)));

		result = new int[0];
		assertTrue(Arrays.equals(result, ArrayTools.subArray(array, 5, 5)));

		result = new int[] {4, 9090, 42};
		assertTrue(Arrays.equals(result, ArrayTools.subArray(array, 3, 6)));
	}

	public void testSubArrayCharArrayIntInt() {
		char[] array = new char[] {'a', 'b', 'c', 'd', 'e', 'f'};
		char[] result = new char[] {'a', 'b', 'c', 'd'};
		assertTrue(Arrays.equals(result, ArrayTools.subArray(array, 0, 4)));

		result = new char[] {'e'};
		assertTrue(Arrays.equals(result, ArrayTools.subArray(array, 4, 5)));

		result = new char[0];
		assertTrue(Arrays.equals(result, ArrayTools.subArray(array, 5, 5)));

		result = new char[] {'d', 'e', 'f'};
		assertTrue(Arrays.equals(result, ArrayTools.subArray(array, 3, 6)));
	}


	// ********** swap **********

	public void testSwapObjectArray() {
		String[] a = this.buildStringArray1();
		a = ArrayTools.swap(a, 1, 2);
		assertEquals("zero", a[0]);
		assertEquals("two", a[1]);
		assertEquals("one", a[2]);
	}

	public void testSwapObjectArray_SameIndices() {
		String[] a1 = this.buildStringArray1();
		String[] a2 = this.buildStringArray1();
		a1 = ArrayTools.swap(a1, 1, 1);
		assertTrue(Arrays.equals(a1, a2));
	}

	public void testSwapCharArray() {
		char[] a = this.buildCharArray();
		a = ArrayTools.swap(a, 1, 2);
		assertEquals('a', a[0]);
		assertEquals('c', a[1]);
		assertEquals('b', a[2]);
	}

	public void testSwapCharArray_SameIndices() {
		char[] a1 = this.buildCharArray();
		char[] a2 = this.buildCharArray();
		a1 = ArrayTools.swap(a1, 1, 1);
		assertTrue(Arrays.equals(a1, a2));
	}

	public void testSwapIntArray() {
		int[] a = this.buildIntArray();
		a = ArrayTools.swap(a, 1, 2);
		assertEquals(0, a[0]);
		assertEquals(20, a[1]);
		assertEquals(10, a[2]);
	}

	public void testSwapIntArray_SameIndices() {
		int[] a1 = this.buildIntArray();
		int[] a2 = this.buildIntArray();
		a1 = ArrayTools.swap(a1, 1, 1);
		assertTrue(Arrays.equals(a1, a2));
	}


	// ********** Arrays enhancements **********

	public void testFillBooleanArrayBoolean() {
		boolean[] a1 = new boolean[9];
		boolean[] a2 = ArrayTools.fill(a1, true);
		for (boolean x : a1) {
			assertTrue(x);
		}
		assertSame(a1, a2);
	}

	public void testFillBooleanArrayIntIntBoolean() {
		boolean[] a1 = new boolean[9];
		boolean[] a2 = ArrayTools.fill(a1, false);
		int from = 3;
		int to = 6;
		boolean[] a3 = ArrayTools.fill(a2, from, to, true);
		for (int i = 0; i < a1.length; i++) {
			boolean x = a1[i];
			if (i < from || i >= to) {
				assertFalse(x);
			} else {
				assertTrue(x);
			}
		}
		assertSame(a1, a2);
		assertSame(a1, a3);
	}

	public void testFillByteArrayByte() {
		byte[] a1 = new byte[9];
		byte[] a2 = ArrayTools.fill(a1, (byte) 77);
		for (byte x : a1) {
			assertEquals(77, x);
		}
		assertSame(a1, a2);
	}

	public void testFillByteArrayIntIntByte() {
		byte[] a1 = new byte[9];
		byte[] a2 = ArrayTools.fill(a1, (byte) 3);
		int from = 3;
		int to = 6;
		byte[] a3 = ArrayTools.fill(a2, from, to, (byte) 77);
		for (int i = 0; i < a1.length; i++) {
			byte x = a1[i];
			if (i < from || i >= to) {
				assertEquals(3, x);
			} else {
				assertEquals(77, x);
			}
		}
		assertSame(a1, a2);
		assertSame(a1, a3);
	}

	public void testFillCharArrayChar() {
		char[] a1 = new char[9];
		char[] a2 = ArrayTools.fill(a1, 'c');
		for (char x : a1) {
			assertEquals('c', x);
		}
		assertSame(a1, a2);
	}

	public void testFillCharArrayIntIntChar() {
		char[] a1 = new char[9];
		char[] a2 = ArrayTools.fill(a1, 'a');
		int from = 3;
		int to = 6;
		char[] a3 = ArrayTools.fill(a2, from, to, 'c');
		for (int i = 0; i < a1.length; i++) {
			char x = a1[i];
			if (i < from || i >= to) {
				assertEquals('a', x);
			} else {
				assertEquals('c', x);
			}
		}
		assertSame(a1, a2);
		assertSame(a1, a3);
	}

	public void testFillDoubleArrayDouble() {
		double[] a1 = new double[9];
		double[] a2 = ArrayTools.fill(a1, 77.77);
		for (double x : a1) {
			assertEquals(77.77, x, 0.0);
		}
		assertSame(a1, a2);
	}

	public void testFillDoubleArrayIntIntDouble() {
		double[] a1 = new double[9];
		double[] a2 = ArrayTools.fill(a1, 3.3);
		int from = 3;
		int to = 6;
		double[] a3 = ArrayTools.fill(a2, from, to, 77.77);
		for (int i = 0; i < a1.length; i++) {
			double x = a1[i];
			if (i < from || i >= to) {
				assertEquals(3.3, x, 0.0);
			} else {
				assertEquals(77.77, x, 0.0);
			}
		}
		assertSame(a1, a2);
		assertSame(a1, a3);
	}

	public void testFillFloatArrayFloat() {
		float[] a1 = new float[9];
		float[] a2 = ArrayTools.fill(a1, 77.77f);
		for (float x : a1) {
			assertEquals(77.77f, x, 0.0);
		}
		assertSame(a1, a2);
	}

	public void testFillFloatArrayIntIntFloat() {
		float[] a1 = new float[9];
		float[] a2 = ArrayTools.fill(a1, 3.3f);
		int from = 3;
		int to = 6;
		float[] a3 = ArrayTools.fill(a2, from, to, 77.77f);
		for (int i = 0; i < a1.length; i++) {
			float x = a1[i];
			if (i < from || i >= to) {
				assertEquals(3.3f, x, 0.0);
			} else {
				assertEquals(77.77f, x, 0.0);
			}
		}
		assertSame(a1, a2);
		assertSame(a1, a3);
	}

	public void testFillIntArrayInt() {
		int[] a1 = new int[9];
		int[] a2 = ArrayTools.fill(a1, 77);
		for (int x : a1) {
			assertEquals(77, x);
		}
		assertSame(a1, a2);
	}

	public void testFillIntArrayIntIntInt() {
		int[] a1 = new int[9];
		int[] a2 = ArrayTools.fill(a1, 3);
		int from = 3;
		int to = 6;
		int[] a3 = ArrayTools.fill(a2, from, to, 77);
		for (int i = 0; i < a1.length; i++) {
			int x = a1[i];
			if (i < from || i >= to) {
				assertEquals(3, x);
			} else {
				assertEquals(77, x);
			}
		}
		assertSame(a1, a2);
		assertSame(a1, a3);
	}

	public void testFillObjectArrayObject() {
		String[] a1 = new String[9];
		String[] a2 = ArrayTools.fill(a1, "77");
		for (String x : a1) {
			assertEquals("77", x);
		}
		assertSame(a1, a2);
	}

	public void testFillObjectArrayIntIntObject() {
		String[] a1 = new String[9];
		String[] a2 = ArrayTools.fill(a1, "3");
		int from = 3;
		int to = 6;
		String[] a3 = ArrayTools.fill(a2, from, to, "77");
		for (int i = 0; i < a1.length; i++) {
			String x = a1[i];
			if (i < from || i >= to) {
				assertEquals("3", x);
			} else {
				assertEquals("77", x);
			}
		}
		assertSame(a1, a2);
		assertSame(a1, a3);
	}

	public void testFillLongArrayLong() {
		long[] a1 = new long[9];
		long[] a2 = ArrayTools.fill(a1, 77);
		for (long x : a1) {
			assertEquals(77, x);
		}
		assertSame(a1, a2);
	}

	public void testFillLongArrayIntIntLong() {
		long[] a1 = new long[9];
		long[] a2 = ArrayTools.fill(a1, 3);
		int from = 3;
		int to = 6;
		long[] a3 = ArrayTools.fill(a2, from, to, 77);
		for (int i = 0; i < a1.length; i++) {
			long x = a1[i];
			if (i < from || i >= to) {
				assertEquals(3, x);
			} else {
				assertEquals(77, x);
			}
		}
		assertSame(a1, a2);
		assertSame(a1, a3);
	}

	public void testFillShortArrayShort() {
		short[] a1 = new short[9];
		short[] a2 = ArrayTools.fill(a1, (short) 77);
		for (short x : a1) {
			assertEquals(77, x);
		}
		assertSame(a1, a2);
	}

	public void testFillShortArrayIntIntShort() {
		short[] a1 = new short[9];
		short[] a2 = ArrayTools.fill(a1, (short) 3);
		int from = 3;
		int to = 6;
		short[] a3 = ArrayTools.fill(a2, from, to, (short) 77);
		for (int i = 0; i < a1.length; i++) {
			short x = a1[i];
			if (i < from || i >= to) {
				assertEquals(3, x);
			} else {
				assertEquals(77, x);
			}
		}
		assertSame(a1, a2);
		assertSame(a1, a3);
	}

	public void testSortByteArray() {
		byte[] a1 = new byte[3];
		a1[0] = (byte) 33;
		a1[1] = (byte) 11;
		a1[2] = (byte) 22;
		byte[] a2 = ArrayTools.sort(a1);
		byte last = (byte) 0;
		for (byte x : a1) {
			assertTrue(last < x);
			last = x;
		}
		assertSame(a1, a2);
	}

	public void testSortByteArrayIntInt() {
		byte[] a1 = new byte[9];
		byte[] a2 = ArrayTools.fill(a1, (byte) 3);
		a2[3] = (byte) 33;
		a2[4] = (byte) 11;
		a2[5] = (byte) 22;
		int from = 3;
		int to = 6;
		byte[] a3 = ArrayTools.sort(a2, from, to);
		byte last = (byte) 0;
		for (int i = 0; i < a1.length; i++) {
			byte x = a1[i];
			if (i < from || i >= to) {
				assertEquals(3, x);
			} else {
				assertTrue(last < x);
				last = x;
			}
		}
		assertSame(a1, a2);
		assertSame(a1, a3);
	}

	public void testSortCharArray() {
		char[] a1 = new char[3];
		a1[0] = 'z';
		a1[1] = 'b';
		a1[2] = 'm';
		char[] a2 = ArrayTools.sort(a1);
		char last = 'a';
		for (char x : a1) {
			assertTrue(last < x);
			last = x;
		}
		assertSame(a1, a2);
	}

	public void testSortCharArrayIntInt() {
		char[] a1 = new char[9];
		char[] a2 = ArrayTools.fill(a1, 'c');
		a2[3] = 'z';
		a2[4] = 'b';
		a2[5] = 'm';
		int from = 3;
		int to = 6;
		char[] a3 = ArrayTools.sort(a2, from, to);
		char last = 'a';
		for (int i = 0; i < a1.length; i++) {
			char x = a1[i];
			if (i < from || i >= to) {
				assertEquals('c', x);
			} else {
				assertTrue(last < x);
				last = x;
			}
		}
		assertSame(a1, a2);
		assertSame(a1, a3);
	}

	public void testSortDoubleArray() {
		double[] a1 = new double[3];
		a1[0] = 33.33;
		a1[1] = 11.11;
		a1[2] = 22.22;
		double[] a2 = ArrayTools.sort(a1);
		double last = 0;
		for (double x : a1) {
			assertTrue(last < x);
			last = x;
		}
		assertSame(a1, a2);
	}

	public void testSortDoubleArrayIntInt() {
		double[] a1 = new double[9];
		double[] a2 = ArrayTools.fill(a1, 3.3);
		a2[3] = 33.33;
		a2[4] = 11.11;
		a2[5] = 22.22;
		int from = 3;
		int to = 6;
		double[] a3 = ArrayTools.sort(a2, from, to);
		double last = 0;
		for (int i = 0; i < a1.length; i++) {
			double x = a1[i];
			if (i < from || i >= to) {
				assertEquals(3.3, x, 0.0);
			} else {
				assertTrue(last < x);
				last = x;
			}
		}
		assertSame(a1, a2);
		assertSame(a1, a3);
	}

	public void testSortFloatArray() {
		float[] a1 = new float[3];
		a1[0] = 33.33f;
		a1[1] = 11.11f;
		a1[2] = 22.22f;
		float[] a2 = ArrayTools.sort(a1);
		float last = 0;
		for (float x : a1) {
			assertTrue(last < x);
			last = x;
		}
		assertSame(a1, a2);
	}

	public void testSortFloatArrayIntInt() {
		float[] a1 = new float[9];
		float[] a2 = ArrayTools.fill(a1, 3.3f);
		a2[3] = 33.33f;
		a2[4] = 11.11f;
		a2[5] = 22.22f;
		int from = 3;
		int to = 6;
		float[] a3 = ArrayTools.sort(a2, from, to);
		float last = 0;
		for (int i = 0; i < a1.length; i++) {
			float x = a1[i];
			if (i < from || i >= to) {
				assertEquals(3.3f, x, 0.0);
			} else {
				assertTrue(last < x);
				last = x;
			}
		}
		assertSame(a1, a2);
		assertSame(a1, a3);
	}

	public void testSortIntArray() {
		int[] a1 = new int[3];
		a1[0] = 33;
		a1[1] = 11;
		a1[2] = 22;
		int[] a2 = ArrayTools.sort(a1);
		int last = 0;
		for (int x : a1) {
			assertTrue(last < x);
			last = x;
		}
		assertSame(a1, a2);
	}

	public void testSortIntArrayIntInt() {
		int[] a1 = new int[9];
		int[] a2 = ArrayTools.fill(a1, 3);
		a2[3] = 33;
		a2[4] = 11;
		a2[5] = 22;
		int from = 3;
		int to = 6;
		int[] a3 = ArrayTools.sort(a2, from, to);
		int last = 0;
		for (int i = 0; i < a1.length; i++) {
			int x = a1[i];
			if (i < from || i >= to) {
				assertEquals(3, x);
			} else {
				assertTrue(last < x);
				last = x;
			}
		}
		assertSame(a1, a2);
		assertSame(a1, a3);
	}

	public void testSortObjectArray() {
		String[] a1 = new String[3];
		a1[0] = "y";
		a1[1] = "b";
		a1[2] = "m";
		String[] a2 = ArrayTools.sort(a1);
		String last = "a";
		for (String x : a1) {
			assertTrue(last.compareTo(x) < 0);
			last = x;
		}
		assertSame(a1, a2);
	}

	public void testSortObjectArrayComparator() {
		String[] a1 = new String[3];
		a1[0] = "y";
		a1[1] = "b";
		a1[2] = "m";
		String[] a2 = ArrayTools.sort(a1, new ReverseComparator<String>());
		String last = "z";
		for (String x : a1) {
			assertTrue(last.compareTo(x) > 0);
			last = x;
		}
		assertSame(a1, a2);
	}

	public void testSortObjectArrayIntInt() {
		String[] a1 = new String[9];
		String[] a2 = ArrayTools.fill(a1, "c");
		a2[3] = "y";
		a2[4] = "b";
		a2[5] = "m";
		int from = 3;
		int to = 6;
		String[] a3 = ArrayTools.sort(a2, from, to);
		String last = "a";
		for (int i = 0; i < a1.length; i++) {
			String x = a1[i];
			if (i < from || i >= to) {
				assertEquals("c", x);
			} else {
				assertTrue(last.compareTo(x) < 0);
				last = x;
			}
		}
		assertSame(a1, a2);
		assertSame(a1, a3);
	}

	public void testSortObjectArrayIntIntComparator() {
		String[] a1 = new String[9];
		String[] a2 = ArrayTools.fill(a1, "c");
		a2[3] = "y";
		a2[4] = "b";
		a2[5] = "m";
		int from = 3;
		int to = 6;
		String[] a3 = ArrayTools.sort(a2, from, to, new ReverseComparator<String>());
		String last = "z";
		for (int i = 0; i < a1.length; i++) {
			String x = a1[i];
			if (i < from || i >= to) {
				assertEquals("c", x);
			} else {
				assertTrue(last.compareTo(x) > 0);
				last = x;
			}
		}
		assertSame(a1, a2);
		assertSame(a1, a3);
	}

	public void testSortLongArray() {
		long[] a1 = new long[3];
		a1[0] = 33;
		a1[1] = 11;
		a1[2] = 22;
		long[] a2 = ArrayTools.sort(a1);
		long last = 0;
		for (long x : a1) {
			assertTrue(last < x);
			last = x;
		}
		assertSame(a1, a2);
	}

	public void testSortLongArrayIntInt() {
		long[] a1 = new long[9];
		long[] a2 = ArrayTools.fill(a1, 3);
		a2[3] = 33;
		a2[4] = 11;
		a2[5] = 22;
		int from = 3;
		int to = 6;
		long[] a3 = ArrayTools.sort(a2, from, to);
		long last = 0;
		for (int i = 0; i < a1.length; i++) {
			long x = a1[i];
			if (i < from || i >= to) {
				assertEquals(3, x);
			} else {
				assertTrue(last < x);
				last = x;
			}
		}
		assertSame(a1, a2);
		assertSame(a1, a3);
	}

	public void testSortShortArray() {
		short[] a1 = new short[3];
		a1[0] = (short) 33;
		a1[1] = (short) 11;
		a1[2] = (short) 22;
		short[] a2 = ArrayTools.sort(a1);
		short last = (short) 0;
		for (short x : a1) {
			assertTrue(last < x);
			last = x;
		}
		assertSame(a1, a2);
	}

	public void testSortShortArrayIntInt() {
		short[] a1 = new short[9];
		short[] a2 = ArrayTools.fill(a1, (short) 3);
		a2[3] = (short) 33;
		a2[4] = (short) 11;
		a2[5] = (short) 22;
		int from = 3;
		int to = 6;
		short[] a3 = ArrayTools.sort(a2, from, to);
		short last = (short) 0;
		for (int i = 0; i < a1.length; i++) {
			short x = a1[i];
			if (i < from || i >= to) {
				assertEquals(3, x);
			} else {
				assertTrue(last < x);
				last = x;
			}
		}
		assertSame(a1, a2);
		assertSame(a1, a3);
	}


	// ********** constructor **********

	public void testConstructor() {
		boolean exCaught = false;
		try {
			Object at = ReflectionTools.newInstance(ArrayTools.class);
			fail("bogus: " + at);
		} catch (RuntimeException ex) {
			if (ex.getCause() instanceof InvocationTargetException) {
				if (ex.getCause().getCause() instanceof UnsupportedOperationException) {
					exCaught = true;
				}
			}
		}
		assertTrue(exCaught);
	}


	// ********** utility **********

	private Object[] buildObjectArray1() {
		return new Object[] { "zero", "one", "two" };
	}

	private String[] buildStringArray1() {
		return new String[] { "zero", "one", "two" };
	}

	private char[] buildCharArray() {
		return new char[] { 'a', 'b', 'c' };
	}

	private int[] buildIntArray() {
		return new int[] { 0, 10, 20 };
	}

	private Object[] buildObjectArray2() {
		return new Object[] { "three", "four", "five" };
	}

	private String[] buildStringArray2() {
		return new String[] { "three", "four", "five" };
	}

	private List<String> buildStringList1() {
		List<String> l = new ArrayList<String>();
		this.addToCollection1(l);
		return l;
	}

	private List<Object> buildObjectList1() {
		List<Object> l = new ArrayList<Object>();
		this.addToCollection1(l);
		return l;
	}

	private void addToCollection1(Collection<? super String> c) {
		c.add("zero");
		c.add("one");
		c.add("two");
	}

	private List<String> buildStringList2() {
		List<String> l = new ArrayList<String>();
		this.addToCollection2(l);
		return l;
	}

	private void addToCollection2(Collection<? super String> c) {
		c.add("three");
		c.add("four");
		c.add("five");
	}

	private Vector<String> buildStringVector1() {
		Vector<String> v = new Vector<String>();
		this.addToCollection1(v);
		return v;
	}

}