queuetest.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;

/**
 * Test suite for the {@link Queue} class.
 * 
 * @depends {@link ArrayUtilsTest}.
 * @author Martin Vysny
 */
public final class QueueTest extends TestCase {
	/**
	 * Test.
	 */
	public void testIfNewQueueIsEmpty() {
		final Queue q = new Queue(100);
		assertTrue("Queue is not empty", q.isEmpty()); //$NON-NLS-1$
	}

	/**
	 * Test.
	 * 
	 * @depends {@link #testIfNewQueueIsEmpty()}
	 */
	public void testIfQueueWithItemIsNotEmpty() {
		final Queue q = new Queue(100);
		assertTrue("Offer failed", q.offer(new Object())); //$NON-NLS-1$
		assertFalse("Queue is empty", q.isEmpty()); //$NON-NLS-1$
	}

	/**
	 * Test.
	 * 
	 * @depends {@link #testIfNewQueueIsEmpty()}
	 */
	public void testIfQueueWith100ElementsIsNotEmpty() {
		final Queue q = new Queue(100);
		final Object test = new Object();
		for (int i = 0; i < 100; i++) {
			assertTrue("Failed to offer test object", q.offer(test)); //$NON-NLS-1$
		}
		assertFalse("Queue is empty", q.isEmpty()); //$NON-NLS-1$
	}

	/**
	 * Test.
	 * 
	 * @depends {@link #testIfNewQueueIsEmpty()}
	 */
	public void testIfQueueWith50ElementsOccupies50Slots() {
		final Queue q = new Queue(100);
		final Object test = new Object();
		for (int i = 0; i < 50; i++) {
			assertTrue("Failed to offer test object", q.offer(test)); //$NON-NLS-1$
		}
		assertEquals("Queue does not occupy 50 slots", 50, q.occupiedSlots()); //$NON-NLS-1$
	}

	/**
	 * Tests if queue with 100 elements is full.
	 * 
	 * @depends {@link #testIfNewQueueIsEmpty()},
	 *          {@link #testIfQueueWith100ElementsIsNotEmpty()}
	 */
	public void testIfQueueWith100ElementsIsFull() {
		final Queue q = new Queue(100);
		final Object test = new Object();
		for (int i = 0; i < 100; i++) {
			assertTrue("Failed to offer test object", q.offer(test)); //$NON-NLS-1$
		}
		assertEquals("Queue does not occupy 100 slots", 100, q.occupiedSlots()); //$NON-NLS-1$
		assertTrue("Queue is not full", q.isFull()); //$NON-NLS-1$
	}

	/**
	 * Test.
	 * 
	 * @depends {@link #testIfNewQueueIsEmpty()},
	 *          {@link #testIfQueueWith50ElementsOccupies50Slots()}
	 */
	public void testIfQueueWithRemovedElementsIsEmpty() {
		final Queue q = new Queue(100);
		final Object test = new Object();
		for (int i = 0; i < 50; i++) {
			assertTrue("Failed to offer test object", q.offer(test)); //$NON-NLS-1$
		}
		for (int i = 0; i < 50; i++) {
			assertNotNull("Failed to poll test object", q.poll()); //$NON-NLS-1$
		}
		assertTrue("Queue is not empty", q.isEmpty()); //$NON-NLS-1$
		for (int i = 0; i < 50; i++) {
			assertTrue("Failed to offer test object", q.offer(test)); //$NON-NLS-1$
		}
		for (int i = 0; i < 50; i++) {
			assertNotNull("Failed to poll test object", q.removeLast()); //$NON-NLS-1$
		}
		assertTrue("Queue is not empty", q.isEmpty()); //$NON-NLS-1$
	}

	/**
	 * Test.
	 * 
	 * @depends {@link #testIfNewQueueIsEmpty()},
	 *          {@link #testIfQueueWith100ElementsIsFull()}
	 */
	public void testIfOfferToZeroSizedQueueFails() {
		final Queue q = new Queue(0);
		assertTrue("Queue is not empty", q.isEmpty()); //$NON-NLS-1$
		assertTrue("Queue is not full", q.isFull()); //$NON-NLS-1$
		assertFalse("Offer succeeded", q.offer(new Object())); //$NON-NLS-1$
	}

	/**
	 * Test.
	 * 
	 * @depends {@link #testIfNewQueueIsEmpty()},
	 *          {@link #testIfQueueWith100ElementsIsFull()}, {@link #testIfOfferToZeroSizedQueueFails()}
	 */
	public void testIfRemoveLastFromEmptyFails() {
		Queue q = new Queue(50);
		assertNull("RemoveLast succeeded", q.removeLast()); //$NON-NLS-1$
		q = new Queue(0);
		assertNull("RemoveLast succeeded", q.removeLast()); //$NON-NLS-1$
		q = new Queue(50);
		q.offer(new Object());
		q.poll();
		assertNull("RemoveLast succeeded", q.removeLast()); //$NON-NLS-1$
	}

	/**
	 * Test
	 * 
	 * @depends {@link #testIfQueueWithRemovedElementsIsEmpty()}
	 */
	public void testIfPollFromEmptyQueueFails() {
		Queue q = new Queue(50);
		assertNull("Poll did not fail", q.poll()); //$NON-NLS-1$
		q = new Queue(0);
		assertNull("Poll did not fail", q.poll()); //$NON-NLS-1$
		q = new Queue(50);
		q.offer(new Object());
		q.poll();
		assertNull("Poll did not fail", q.poll()); //$NON-NLS-1$
	}

	/**
	 * Test
	 * 
	 * @depends {@link #testIfQueueWithItemIsNotEmpty()},
	 *          {@link #testIfOfferToZeroSizedQueueFails()}
	 */
	public void testClearedQueueIsEmpty() {
		Queue q = new Queue(50);
		q.offer(new Object());
		q.offer(new Object());
		q.clear();
		assertTrue("Queue is not empty", q.isEmpty()); //$NON-NLS-1$
		q = new Queue(0);
		q.clear();
		assertTrue("Queue is not empty", q.isEmpty()); //$NON-NLS-1$
	}

	/**
	 * Test.
	 */
	public void testOfferAndPollPreservesElementsOrder() {
		final Queue q = new Queue(50);
		Object o1 = new Object();
		Object o2 = new Object();
		Object o3 = new Object();
		q.offer(o1);
		q.offer(o2);
		q.offer(o3);
		assertSame("Polled object differs", q.poll(), o1); //$NON-NLS-1$
		assertSame("Polled object differs", q.poll(), o2); //$NON-NLS-1$
		assertSame("Polled object differs", q.poll(), o3); //$NON-NLS-1$
	}

	/**
	 * Test.
	 */
	public void testOfferAndRemoveLastPreservesElementsOrder() {
		final Queue q = new Queue(3);
		Object o1 = new Object();
		Object o2 = new Object();
		Object o3 = new Object();
		q.offer(o1);
		q.offer(o2);
		q.offer(o3);
		assertSame("Removed object differs", q.removeLast(), o3); //$NON-NLS-1$
		assertSame("Removed object differs", q.removeLast(), o2); //$NON-NLS-1$
		assertSame("Removed object differs", q.removeLast(), o1); //$NON-NLS-1$
	}

	/**
	 * Test.
	 * 
	 * @depends {@link #testOfferAndPollPreservesElementsOrder()}
	 */
	public void testOfferZeroElementsLeavesQueueEmpty() {
		final Queue q = new Queue(50);
		assertTrue("Failed to add zero elements", q.offerAll(new Vector() //$NON-NLS-1$
				.elements()));
		assertTrue("Queue is not empty", q.isEmpty()); //$NON-NLS-1$
	}

	/**
	 * Test
	 */
	public void testEnumerationOfEmptyQueueIsEmpty() {
		final Queue q = new Queue(50);
		assertFalse("Enumeration is not empty", q.getEnumeration() //$NON-NLS-1$
				.hasMoreElements());
	}

	/**
	 * Test
	 * 
	 * @depends {@link #testIfQueueWithItemIsNotEmpty()},
	 *          {@link #testEnumerationOfEmptyQueueIsEmpty()}
	 */
	public void testEnumerationOfNonEmptyQueueIsNonEmpty() {
		final Queue q = new Queue(50);
		q.offer(new Object());
		assertTrue("Enumeration is empty", q.getEnumeration().hasMoreElements()); //$NON-NLS-1$
	}

	/**
	 * Test.
	 */
	public void testOfferAllPreservesElementsOrder() {
		final Queue q = new Queue(50);
		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("Failed to add elements", q //$NON-NLS-1$
				.offerAll(objectVector.elements()));
		assertTrue("Elements are in incorrect ordering", ArrayUtils.equals(q //$NON-NLS-1$
				.getEnumeration(), objectArray));
	}

	/**
	 * Test.
	 */
	public void testIfOfferAllFailsOnItself() {
		final Queue q = new Queue(50);
		try {
			q.offerAll(q);
			fail("Should fail"); //$NON-NLS-1$
		} catch (IllegalArgumentException ex) {
			// okay
		}
	}

	/**
	 * Test.
	 */
	public void testIfEmptyCloneIsEmpty() {
		final Queue q = new Queue(50);
		final Queue q2 = new Queue(q);
		assertTrue("Clone should be empty", q2.isEmpty()); //$NON-NLS-1$
	}

	/**
	 * Test.
	 * 
	 * @depends {@link #testIfQueueWithItemIsNotEmpty()}
	 */
	public void testNonEmptyCloneIsNonEmpty() {
		final Queue q = new Queue(50);
		q.offer(new Object());
		q.offer(new Object());
		q.offer(new Object());
		final Queue q2 = new Queue(q);
		assertFalse("Clone should not be empty", q2.isEmpty()); //$NON-NLS-1$
	}

	/**
	 * Test.
	 * 
	 * @depends {@link #testIfEmptyCloneIsEmpty()}
	 */
	public void testIfCloneIsEqual() {
		final Queue q = new Queue(50);
		final Queue q2 = new Queue(q);
		assertTrue("Clone should be equal to original", ArrayUtils.equals(q //$NON-NLS-1$
				.getEnumeration(), q2.getEnumeration()));
	}

	/**
	 * Test.
	 * 
	 * @depends {@link #testIfNewQueueIsEmpty()}
	 */
	public void testPeekOnEmptyQueueReturnsNull() {
		final Queue q = new Queue(50);
		assertNull("Peek should return null", q.peek()); //$NON-NLS-1$
		assertNull("Peek should return null", q.peek(0)); //$NON-NLS-1$
		assertNull("Peek should return null", q.peek(1)); //$NON-NLS-1$
		assertNull("Peek should return null", q.peek(6)); //$NON-NLS-1$
	}

	/**
	 * Test.
	 * 
	 * @depends {@link #testIfNewQueueIsEmpty()}
	 */
	public void testPeekPreservesElementOrder() {
		final Queue q = new Queue(50);
		final byte[] items = new byte[] { 5, 10, -2, -7, 8, 0 };
		q.offerAll(ArrayUtils.arrayToEnumeration(items));
		for (int i = 0; i < items.length; i++) {
			if (i == 0)
				assertEquals("Head should be " + items[0], new Byte(items[0]), //$NON-NLS-1$
						q.peek());
			assertEquals("Head-" + i + " should be " + items[i], new Byte( //$NON-NLS-1$ //$NON-NLS-2$
					items[i]), q.peek(i));
		}
		assertNull("Queue should not contain so much items", q //$NON-NLS-1$
				.peek(items.length));
	}
}