diff options
Diffstat (limited to 'common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/ArrayToolsTests.java')
-rw-r--r-- | common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/ArrayToolsTests.java | 3523 |
1 files changed, 0 insertions, 3523 deletions
diff --git a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/ArrayToolsTests.java b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/ArrayToolsTests.java deleted file mode 100644 index b5f840729f..0000000000 --- a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/ArrayToolsTests.java +++ /dev/null @@ -1,3523 +0,0 @@ -/******************************************************************************* - * 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.common.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.common.utility.internal.ArrayTools; -import org.eclipse.jpt.common.utility.internal.Range; -import org.eclipse.jpt.common.utility.internal.ReflectionTools; -import org.eclipse.jpt.common.utility.internal.ReverseComparator; -import org.eclipse.jpt.common.utility.internal.iterators.EmptyIterator; - -@SuppressWarnings("nls") -public class ArrayToolsTests extends TestCase { - - public ArrayToolsTests(String name) { - super(name); - } - - - // ********** instantiation ********** - - public void testNewArrayObjectArray() { - String[] array1 = new String[2]; - String[] array2 = ArrayTools.newArray(array1); - array2[0] = "foo"; - array2[1] = "bar"; - assertEquals(String.class, array2.getClass().getComponentType()); - assertEquals(2, array2.length); - } - - 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; - } - -} |