arrayutilstest.java

BT JAVA LIBRARY,BTLib package is a J2ME Bluetooth library usefull when developing applications for J

/*
 The Bluetooth Library for client-server communication
 Copyright (C) 2006 Martin Vysny

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 */
package net.sf.btw.tools;

import java.util.Vector;

import junit.framework.TestCase;

/**
 * The test cases for {@link ArrayUtils} class.
 * 
 * @author Martin Vysny
 * 
 */
public final class ArrayUtilsTest extends TestCase {
	/**
	 * Test.
	 */
	public void testIfObjectsAreArray() {
		assertTrue("Vector is an array", ArrayUtils.isArray(new Vector())); //$NON-NLS-1$
		assertTrue("Queue is an array", ArrayUtils.isArray(new Queue(5))); //$NON-NLS-1$
		assertTrue("Enumeration is an array", ArrayUtils.isArray(new Queue(5) //$NON-NLS-1$
				.getEnumeration()));
		assertTrue("byte[] is an array", ArrayUtils.isArray(new byte[0])); //$NON-NLS-1$
		assertTrue("short[] is an array", ArrayUtils.isArray(new short[0])); //$NON-NLS-1$
		assertTrue("int[] is an array", ArrayUtils.isArray(new int[0])); //$NON-NLS-1$
		assertTrue("Object[] is an array", ArrayUtils.isArray(new Object[0])); //$NON-NLS-1$
		assertTrue("boolean[] is an array", ArrayUtils.isArray(new boolean[0])); //$NON-NLS-1$
		assertTrue("long[] is an array", ArrayUtils.isArray(new long[0])); //$NON-NLS-1$
		assertFalse("Object is not an array", ArrayUtils.isArray(new Object())); //$NON-NLS-1$
		assertFalse("null is not an array", ArrayUtils.isArray(null)); //$NON-NLS-1$
		assertFalse("String is not an array", ArrayUtils.isArray("huhu")); //$NON-NLS-1$ //$NON-NLS-2$
	}

	/**
	 * Test.
	 */
	public void testArrayHashCode() {
		assertEquals("Nonzero hashcode", 0, ArrayUtils.hashCode(null)); //$NON-NLS-1$
		Object[] a1 = new Object[] { new Object(), new Object() };
		Object[] a2 = new Object[] { a1[0], a1[1] };
		assertEquals("Wrong hashcode", ArrayUtils.hashCode(a1), ArrayUtils //$NON-NLS-1$
				.hashCode(a2));
		assertEquals("Wrong hashcode", ArrayUtils.hashCode(a2), ArrayUtils //$NON-NLS-1$
				.hashCode(a1));
		assertEquals("Wrong hashcode", ArrayUtils.hashCode(a1), ArrayUtils //$NON-NLS-1$
				.hashCode(a1));
		a1 = new Object[] { a1, new Object() };
		a2 = new Object[] { a2, a1[1] };
		assertEquals("Wrong hashcode", ArrayUtils.hashCode(a1), ArrayUtils //$NON-NLS-1$
				.hashCode(a2));
		assertEquals("Wrong hashcode", ArrayUtils.hashCode(a2), ArrayUtils //$NON-NLS-1$
				.hashCode(a1));
		assertEquals("Wrong hashcode", ArrayUtils.hashCode(a1), ArrayUtils //$NON-NLS-1$
				.hashCode(a1));
	}

	/**
	 * Test.
	 */
	public void testIndexOfFailsOnEmptyVector() {
		final Vector v = new Vector();
		assertEquals("Item found", -1, ArrayUtils.indexOf(v, null)); //$NON-NLS-1$
		assertEquals("Item found", -1, ArrayUtils.indexOf(v, new Object())); //$NON-NLS-1$
		assertEquals("Item found", -1, ArrayUtils.indexOf(v, v)); //$NON-NLS-1$
	}

	/**
	 * Test.
	 * 
	 * @depends {@link #testIndexOfFailsOnEmptyVector()}
	 */
	public void testIndexOfFindsFirstItem() {
		final Vector v = new Vector();
		v.addElement(null);
		v.addElement(null);
		v.addElement(new Object());
		v.addElement(null);
		v.addElement(new Object());
		assertEquals("Item not found", 0, ArrayUtils.indexOf(v, null)); //$NON-NLS-1$
		assertEquals("Item not found", 2, ArrayUtils.indexOf(v, v.elementAt(2))); //$NON-NLS-1$
	}

	/**
	 * Test.
	 */
	public void testComparingEmptyEnumsReturnsTrue() {
		assertTrue("Comparing failed", ArrayUtils.equals(new Vector() //$NON-NLS-1$
				.elements(), new Vector().elements()));
		assertTrue("Comparing failed", ArrayUtils.equals(new Vector() //$NON-NLS-1$
				.elements(), new Object[0]));
		assertTrue("Comparing failed", ArrayUtils.equals(new Object[0], //$NON-NLS-1$
				new Object[0]));
	}

	/**
	 * Test.
	 * 
	 * @depends {@link #testComparingEmptyEnumsReturnsTrue()}
	 */
	public void testComparingDifferentEnumsReturnsFalse() {
		final Vector v1 = new Vector();
		v1.addElement(new Object());
		final Vector v2 = new Vector();
		v2.addElement(new Object());
		assertFalse("Comparing failed", ArrayUtils.equals(new Vector() //$NON-NLS-1$
				.elements(), v1.elements()));
		assertFalse("Comparing failed", ArrayUtils.equals(v1.elements(), //$NON-NLS-1$
				new Vector().elements()));
		assertFalse("Comparing failed", ArrayUtils.equals(v1.elements(), v2 //$NON-NLS-1$
				.elements()));
		assertFalse("Comparing failed", ArrayUtils.equals(new Vector() //$NON-NLS-1$
				.elements(), new Object[] { new Object() }));
		assertFalse("Comparing failed", ArrayUtils.equals(v1.elements(), //$NON-NLS-1$
				new Object[0]));
		assertFalse("Comparing failed", ArrayUtils.equals(v1.elements(), //$NON-NLS-1$
				new Object[] { new Object() }));
		assertFalse("Comparing failed", ArrayUtils.equals(new Object[0], //$NON-NLS-1$
				new Object[] { new Object() }));
		assertFalse("Comparing failed", ArrayUtils.equals( //$NON-NLS-1$
				new Object[] { new Object() }, new Object[0]));
		assertFalse("Comparing failed", ArrayUtils.equals( //$NON-NLS-1$
				new Object[] { new Object() }, new Object[] { new Object() }));
		v2.setElementAt(v1.elementAt(0), 0);
		v2.addElement(new Object());
		assertFalse("Comparing failed", ArrayUtils.equals(v1.elements(), v2 //$NON-NLS-1$
				.elements()));
		assertFalse("Comparing failed", ArrayUtils.equals(v1.elements(), //$NON-NLS-1$
				new Object[] { v1.elementAt(0), new Object() }));
		assertFalse("Comparing failed", ArrayUtils //$NON-NLS-1$
				.equals(new Object[] { v1.elementAt(0) }, new Object[] {
						v1.elementAt(0), new Object() }));
	}

	/**
	 * Test.
	 * 
	 * @depends {@link #testComparingDifferentEnumsReturnsFalse}
	 */
	public void testComparingEqualEnumsReturnsTrue() {
		final Vector v1 = new Vector();
		v1.addElement(new Object());
		v1.addElement(new Object());
		final Vector v2 = new Vector();
		v2.addElement(v1.elementAt(0));
		v2.addElement(v1.elementAt(1));
		final Object[] a1 = new Object[] { v1.elementAt(0), v1.elementAt(1) };
		final Object[] a2 = new Object[] { a1[0], a1[1] };
		assertTrue("Comparing failed", ArrayUtils.equals(v1.elements(), v1 //$NON-NLS-1$
				.elements()));
		assertTrue("Comparing failed", ArrayUtils.equals(v2.elements(), v1 //$NON-NLS-1$
				.elements()));
		assertTrue("Comparing failed", ArrayUtils.equals(v1.elements(), v2 //$NON-NLS-1$
				.elements()));
		assertTrue("Comparing failed", ArrayUtils.equals(v1.elements(), a1)); //$NON-NLS-1$
		assertTrue("Comparing failed", ArrayUtils.equals(v2.elements(), a1)); //$NON-NLS-1$
		assertTrue("Comparing failed", ArrayUtils.equals(v1.elements(), a2)); //$NON-NLS-1$
		assertTrue("Comparing failed", ArrayUtils.equals(a1, a1)); //$NON-NLS-1$
		assertTrue("Comparing failed", ArrayUtils.equals(a1, a2)); //$NON-NLS-1$
		assertTrue("Comparing failed", ArrayUtils.equals(a2, a1)); //$NON-NLS-1$
		v1.addElement(a1);
		v2.addElement(a1);
		assertTrue("Comparing failed", ArrayUtils.equals(v1, v2)); //$NON-NLS-1$
	}

	/**
	 * Test.
	 * 
	 * @depends {@link #testComparingDifferentEnumsReturnsFalse()},
	 *          {@link #testComparingDifferentEnumsReturnsFalse}
	 */
	public void testAddAllPreservesElementsOrder() {
		final Object o1 = new Object();
		final Object[] objectArray = new Object[] { new Object(), o1,
				new Object(), o1, o1, new Object() };
		final Vector objectVector = new Vector();
		ArrayUtils.addAll(objectVector, objectArray);
		assertTrue("Lists differ", ArrayUtils.equals(objectVector.elements(), //$NON-NLS-1$
				objectArray));
		objectVector.removeAllElements();
		ArrayUtils.addAll(objectVector, (Object) objectArray);
		assertTrue("Lists differ", ArrayUtils.equals(objectVector.elements(), //$NON-NLS-1$
				objectArray));
		objectVector.removeAllElements();
		final int[] intArray = new int[] { 0, 5, 6, 7, 10 };
		ArrayUtils.addAll(objectVector, intArray);
		assertTrue("Lists differ", ArrayUtils.equals(objectVector, intArray)); //$NON-NLS-1$
	}

	/**
	 * Test.
	 * 
	 * @depends {@link #testComparingDifferentEnumsReturnsFalse()},
	 *          {@link #testComparingEmptyEnumsReturnsTrue()},
	 *          {@link #testComparingEqualEnumsReturnsTrue()},
	 *          {@link #testConversionOfPrimitiveArraysToEnumeration()},
	 *          {@link #testConversionOfPrimitiveArraysToEnumeration()}.
	 */
	public void testConversionOfPrimitiveArraysToEnumeration() {
		final int[] a1 = new int[] { 0, 1, 6, 3, 2 };
		final Vector v1 = new Vector();
		ArrayUtils.addAll(v1, a1);
		assertTrue("Enumerations should be equal", ArrayUtils.equals(a1, v1)); //$NON-NLS-1$
		final byte[] a2 = new byte[] { 0, 1, 6, 3, 2 };
		v1.removeAllElements();
		ArrayUtils.addAll(v1, a2);
		assertTrue("Enumerations should be equal", ArrayUtils.equals(a2, v1)); //$NON-NLS-1$
		final long[] a3 = new long[] { 0, 1, 6, 3, 2 };
		v1.removeAllElements();
		ArrayUtils.addAll(v1, a3);
		assertTrue("Enumerations should be equal", ArrayUtils.equals(a3, v1)); //$NON-NLS-1$
		final boolean[] a4 = new boolean[] { true, false, true, true, false,
				true };
		v1.removeAllElements();
		ArrayUtils.addAll(v1, a4);
		assertTrue("Enumerations should be equal", ArrayUtils.equals(a4, v1)); //$NON-NLS-1$
		final short[] a5 = new short[] { 0, 1, 6, 3, 2 };
		v1.removeAllElements();
		ArrayUtils.addAll(v1, a5);
		assertTrue("Enumerations should be equal", ArrayUtils.equals(a5, v1)); //$NON-NLS-1$
	}

	/**
	 * Test.
	 */
	public void testCloneCreatesNewObject() {
		final int[] a1 = new int[] { 0, 1, 6, 3, 2 };
		assertNotSame(ArrayUtils.clone(a1, false), a1);
		final byte[] a2 = new byte[] { 0, 1, 6, 3, 2 };
		assertNotSame(ArrayUtils.clone(a2, false), a2);
		final long[] a3 = new long[] { 0, 1, 6, 3, 2 };
		assertNotSame(ArrayUtils.clone(a3, false), a3);
		final boolean[] a4 = new boolean[] { true, false, true, true, false,
				true };
		assertNotSame(ArrayUtils.clone(a4, false), a4);
		final short[] a5 = new short[] { 0, 1, 6, 3, 2 };
		assertNotSame(ArrayUtils.clone(a5, false), a5);
		final Vector v1 = new Vector();
		ArrayUtils.addAll(v1, a1);
		ArrayUtils.addAll(v1, a2);
		assertNotSame(ArrayUtils.clone(v1, false), v1);
	}

	/**
	 * Test.
	 * 
	 * @depends {@link #testConversionOfPrimitiveArraysToEnumeration()}
	 */
	public void testCloneEqualToOriginal() {
		final int[] a1 = new int[] { 0, 1, 6, 3, 2 };
		assertTrue("int[] should be returned", ArrayUtils.clone(a1, false) //$NON-NLS-1$
				.getClass().isInstance(new int[0]));
		assertTrue("Clone should be equal", ArrayUtils.equals(a1, ArrayUtils //$NON-NLS-1$
				.clone(a1, false)));
		assertTrue("Clone should be equal", ArrayUtils.equals(a1, ArrayUtils //$NON-NLS-1$
				.clone(a1, true)));
		final byte[] a2 = new byte[] { 0, 1, 6, 3, 2 };
		assertTrue("byte[] should be returned", ArrayUtils.clone(a2, false) //$NON-NLS-1$
				.getClass().isInstance(new byte[0]));
		assertTrue("Clone should be equal", ArrayUtils.equals(a2, ArrayUtils //$NON-NLS-1$
				.clone(a2, false)));
		assertTrue("Clone should be equal", ArrayUtils.equals(a2, ArrayUtils //$NON-NLS-1$
				.clone(a2, true)));
		final long[] a3 = new long[] { 0, 1, 6, 3, 2 };
		assertTrue("long[] should be returned", ArrayUtils.clone(a3, false) //$NON-NLS-1$
				.getClass().isInstance(new long[0]));
		assertTrue("Clone should be equal", ArrayUtils.equals(a3, ArrayUtils //$NON-NLS-1$
				.clone(a3, false)));
		assertTrue("Clone should be equal", ArrayUtils.equals(a3, ArrayUtils //$NON-NLS-1$
				.clone(a3, true)));
		final boolean[] a4 = new boolean[] { true, false, true, true, false,
				true };
		assertTrue("boolean[] should be returned", ArrayUtils.clone(a4, false) //$NON-NLS-1$
				.getClass().isInstance(new boolean[0]));
		assertTrue("Clone should be equal", ArrayUtils.equals(a4, ArrayUtils //$NON-NLS-1$
				.clone(a4, false)));
		assertTrue("Clone should be equal", ArrayUtils.equals(a4, ArrayUtils //$NON-NLS-1$
				.clone(a4, true)));
		final short[] a5 = new short[] { 0, 1, 6, 3, 2 };
		assertTrue("short[] should be returned", ArrayUtils.clone(a5, false) //$NON-NLS-1$
				.getClass().isInstance(new short[0]));
		assertTrue("Clone should be equal", ArrayUtils.equals(a5, ArrayUtils //$NON-NLS-1$
				.clone(a5, false)));
		assertTrue("Clone should be equal", ArrayUtils.equals(a5, ArrayUtils //$NON-NLS-1$
				.clone(a5, true)));
		final Vector v1 = new Vector();
		ArrayUtils.addAll(v1, a1);
		ArrayUtils.addAll(v1, a2);
		ArrayUtils.addAll(v1, a3);
		ArrayUtils.addAll(v1, a4);
		ArrayUtils.addAll(v1, a5);
		assertTrue("Vector should be returned", //$NON-NLS-1$
				ArrayUtils.clone(v1, false) instanceof Vector);
		assertTrue("Clone should be equal", ArrayUtils.equals(v1, ArrayUtils //$NON-NLS-1$
				.clone(v1, false)));
		assertTrue("Clone should be equal", ArrayUtils.equals(v1, ArrayUtils //$NON-NLS-1$
				.clone(v1, true)));
		// deep copy test
		final Vector v2 = new Vector();
		v2.addElement(a1);
		v2.addElement(v1);
		v2.addElement(a3);
		v2.addElement(v1);
		v2.addElement(a5);
		assertTrue("Clone should be equal", ArrayUtils.equals(v2, ArrayUtils //$NON-NLS-1$
				.clone(v2, false)));
		assertTrue("Clone should be equal", ArrayUtils.equals(v2, ArrayUtils //$NON-NLS-1$
				.clone(v2, true)));
		Vector clone = (Vector) ArrayUtils.clone(v2, true);
		assertNotSame("Deep clone should not contain same arrays", v1, clone //$NON-NLS-1$
				.elementAt(1));
		assertNotSame("Deep clone should not contain same arrays", v1, clone //$NON-NLS-1$
				.elementAt(3));
		assertTrue("Deep clone should clone sub-arrays properly", ArrayUtils //$NON-NLS-1$
				.equals(v1, clone.elementAt(1)));
		assertTrue("Deep clone should clone sub-arrays properly", ArrayUtils //$NON-NLS-1$
				.equals(v1, clone.elementAt(3)));
		clone = (Vector) ArrayUtils.clone(v2, false);
		assertSame("Non-deep clone should contain same arrays", v1, clone //$NON-NLS-1$
				.elementAt(1));
		assertSame("Non-deep clone should contain same arrays", v1, clone //$NON-NLS-1$
				.elementAt(3));
	}
}