/*******************************************************************************
 * Copyright (c) 2011, 2012 Obeo.
 * 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:
 *     Obeo - initial API and implementation
 *******************************************************************************/
package org.eclipse.acceleo.common.tests.unit.utils;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.ConcurrentModificationException;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;
import java.util.Set;

import org.eclipse.acceleo.common.utils.CircularArrayDeque;
import org.eclipse.acceleo.common.utils.Deque;
import org.junit.Test;

/**
 * Tests for the {@link CircularArrayDeque} behavior.
 * 
 * @author <a href="mailto:laurent.goubet@obeo.fr">Laurent Goubet</a>
 */
@SuppressWarnings("nls")
public class CircularArrayDequeTest {
	/**
	 * Tests the behavior of {@link CircularArrayDeque#add(Object)} with random elements.
	 */
	@Test
	public void testAdd() {
		Integer integer1 = -1;
		Integer integer2 = -2;
		String string1 = "a";
		String string2 = "b";
		Object object1 = new Object();
		Object object2 = new Object();

		Deque<Object> deque = new CircularArrayDeque<Object>();

		boolean modified = deque.add(integer1);
		assertTrue(modified);
		assertSame(1, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.getLast());
		assertEquals(integer1, deque.peek());

		modified = deque.add(integer2);
		assertTrue(modified);
		assertSame(2, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertEquals(integer2, deque.getLast());

		modified = deque.add(string1);
		assertTrue(modified);
		assertSame(3, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertEquals(string1, deque.getLast());

		modified = deque.add(string2);
		assertTrue(modified);
		assertSame(4, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertEquals(string2, deque.getLast());

		modified = deque.add(object1);
		assertTrue(modified);
		assertSame(5, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertEquals(object1, deque.getLast());

		modified = deque.add(object2);
		assertTrue(modified);
		assertSame(6, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertEquals(object2, deque.getLast());

		modified = deque.add(null);
		assertTrue(modified);
		assertSame(7, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertSame(null, deque.getLast());

		deque.pop();
		assertSame(6, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertEquals(object2, deque.getLast());

		modified = deque.add(null);
		assertTrue(modified);
		assertSame(7, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertSame(null, deque.getLast());

		// Ensure we go above capacity
		for (int i = 0; i < 100; i++) {
			String rand = getRandomString();
			while (deque.contains(rand)) {
				rand = getRandomString();
			}
			deque.add(rand);
			assertSame(7 + i + 1, deque.size());
			assertEquals(integer1, deque.getFirst());
			assertEquals(integer1, deque.peek());
			assertSame(rand, deque.getLast());
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#addAll(Collection)} with random elements.
	 */
	@Test
	public void testAddAll() {
		Collection<Object> emptyCollection = Collections.emptyList();
		Collection<Integer> listInt10 = randomIntegerListNotIn(10, Collections.emptySet());
		Collection<String> setString20 = randomStringSetNotIn(20, Collections.emptySet());
		Collection<String> dequeString40 = randomStringDequeNotIn(40, setString20);

		Deque<Object> deque = new CircularArrayDeque<Object>();

		boolean modified = deque.addAll(listInt10);
		assertTrue(modified);
		assertEquals(listInt10.size(), deque.size());
		assertTrue(deque.containsAll(listInt10));
		assertEquals(getNextPowerOfTwo(deque.size()), getInternalCapacity(deque));

		modified = deque.addAll(emptyCollection);
		assertFalse(modified);
		assertEquals(listInt10.size(), deque.size());
		assertTrue(deque.containsAll(listInt10));
		assertEquals(getNextPowerOfTwo(deque.size()), getInternalCapacity(deque));

		modified = deque.addAll(setString20);
		assertTrue(modified);
		assertEquals(listInt10.size() + setString20.size(), deque.size());
		assertTrue(deque.containsAll(listInt10));
		assertTrue(deque.containsAll(setString20));
		assertEquals(getNextPowerOfTwo(deque.size()), getInternalCapacity(deque));

		modified = deque.addAll(dequeString40);
		assertTrue(modified);
		assertEquals(listInt10.size() + setString20.size() + dequeString40.size(), deque.size());
		assertTrue(deque.containsAll(listInt10));
		assertTrue(deque.containsAll(setString20));
		assertTrue(deque.containsAll(dequeString40));
		int expectedCapacity = getNextPowerOfTwo(deque.size());
		assertEquals(expectedCapacity, getInternalCapacity(deque));

		for (@SuppressWarnings("unused")
		Integer val : listInt10) {
			deque.removeFirst();
		}
		assertEquals(setString20.size() + dequeString40.size(), deque.size());
		assertFalse(deque.containsAll(listInt10));
		assertTrue(deque.containsAll(setString20));
		assertTrue(deque.containsAll(dequeString40));
		assertEquals(expectedCapacity, getInternalCapacity(deque));

		modified = deque.addAll(listInt10);
		assertTrue(modified);
		assertEquals(listInt10.size() + setString20.size() + dequeString40.size(), deque.size());
		assertTrue(deque.containsAll(listInt10));
		assertTrue(deque.containsAll(setString20));
		assertTrue(deque.containsAll(dequeString40));
		assertEquals(getNextPowerOfTwo(deque.size()), getInternalCapacity(deque));

		modified = deque.addAll(emptyCollection);
		assertFalse(modified);
		assertEquals(listInt10.size() + setString20.size() + dequeString40.size(), deque.size());
		assertTrue(deque.containsAll(listInt10));
		assertTrue(deque.containsAll(setString20));
		assertTrue(deque.containsAll(dequeString40));
		assertEquals(getNextPowerOfTwo(deque.size()), getInternalCapacity(deque));
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#addAll(Collection)} with random elements.
	 */
	@Test
	public void testAddAllRandomAccess() {
		Collection<Object> emptyCollection = Collections.emptyList();
		Collection<Integer> listInt10 = randomIntegerListNotIn(10, Collections.emptySet());
		Collection<String> setString20 = randomStringSetNotIn(20, Collections.emptySet());
		Collection<String> dequeString40 = randomStringDequeNotIn(40, setString20);

		/*
		 * we'll do this five times : one by adding at the beginning (0), one by adding at the end
		 * (deque.size), one by adding in the first half (deque.size / 4), one by adding in the last half
		 * (deque.size / 4 * 3) and finally by adding at the middle (deque.size / 2).
		 */
		for (int i = 0; i < 5; i++) {
			Deque<Object> deque = new CircularArrayDeque<Object>();

			int insertionIndex = 0;
			if (i == 1) {
				insertionIndex = deque.size();
			} else if (i == 2) {
				insertionIndex = deque.size() / 4;
			} else if (i == 3) {
				insertionIndex = deque.size() / 4 * 3;
			} else if (i == 4) {
				insertionIndex = deque.size() / 2;
			}
			boolean modified = deque.addAll(insertionIndex, emptyCollection);
			assertFalse(modified);
			assertEquals(0, deque.size());
			assertEquals(16, getInternalCapacity(deque));

			insertionIndex = 0;
			if (i == 1) {
				insertionIndex = deque.size();
			} else if (i == 2) {
				insertionIndex = deque.size() / 4;
			} else if (i == 3) {
				insertionIndex = deque.size() / 4 * 3;
			} else if (i == 4) {
				insertionIndex = deque.size() / 2;
			}
			modified = deque.addAll(insertionIndex, listInt10);
			assertTrue(modified);
			assertEquals(listInt10.size(), deque.size());
			assertTrue(deque.containsAll(listInt10));
			assertEquals(getNextPowerOfTwo(deque.size()), getInternalCapacity(deque));

			insertionIndex = 0;
			if (i == 1) {
				insertionIndex = deque.size();
			} else if (i == 2) {
				insertionIndex = deque.size() / 4;
			} else if (i == 3) {
				insertionIndex = deque.size() / 4 * 3;
			} else if (i == 4) {
				insertionIndex = deque.size() / 2;
			}
			modified = deque.addAll(insertionIndex, setString20);
			assertTrue(modified);
			assertEquals(listInt10.size() + setString20.size(), deque.size());
			assertTrue(deque.containsAll(listInt10));
			assertTrue(deque.containsAll(setString20));
			assertEquals(getNextPowerOfTwo(deque.size()), getInternalCapacity(deque));

			insertionIndex = 0;
			if (i == 1) {
				insertionIndex = deque.size();
			} else if (i == 2) {
				insertionIndex = deque.size() / 4;
			} else if (i == 3) {
				insertionIndex = deque.size() / 4 * 3;
			} else if (i == 4) {
				insertionIndex = deque.size() / 2;
			}
			modified = deque.addAll(insertionIndex, dequeString40);
			assertTrue(modified);
			assertEquals(listInt10.size() + setString20.size() + dequeString40.size(), deque.size());
			assertTrue(deque.containsAll(listInt10));
			assertTrue(deque.containsAll(setString20));
			assertTrue(deque.containsAll(dequeString40));
			assertEquals(getNextPowerOfTwo(deque.size()), getInternalCapacity(deque));
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#addAll(int, Collection)} with random elements.
	 */
	@Test
	public void testAddAllRandomAccessLeftRotate() {
		Object[] testObjects = new Object[] {"abcd", "", "*", "?", "\n", '\'', null, 4, 4.3, 5L, 4.3d, //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
				new Object() };

		for (int i = 0; i < testObjects.length; i++) {
			List<Object> testCollection = new ArrayList<Object>();
			testCollection.add(testObjects[i]);
			testCollection.add(testObjects[testObjects.length - 1 - i]);
			internalTestAddAllRandomAccessLeftRotate(testCollection);
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#addAll(int, Collection)} with random elements.
	 */
	@Test
	public void testAddAllRandomAccessRightRotate() {
		Object[] testObjects = new Object[] {"abcd", "", "*", "?", "\n", '\'', null, 4, 4.3, 5L, 4.3d, //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
				new Object() };

		for (int i = 0; i < testObjects.length; i++) {
			List<Object> testCollection = new ArrayList<Object>();
			testCollection.add(testObjects[i]);
			testCollection.add(testObjects[testObjects.length - 1 - i]);
			internalTestAddAllRandomAccessRightRotate(testCollection);
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#addAll(int, Collection)} with random elements but with
	 * out of bounds indices.
	 */
	@Test
	public void testAddAllRandomOutOfBounds() {
		Deque<Object> deque = new CircularArrayDeque<Object>();
		Object[] testObjects = new Object[] {"abcd", "", "*", "?", "\n", '\'', null, 4, 4.3, 5L, 4.3d, //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
				new Object() };

		for (int i = 0; i < testObjects.length; i++) {
			List<Object> testCollection = new ArrayList<Object>();
			testCollection.add(testObjects[i]);
			testCollection.add(testObjects[testObjects.length - 1 - i]);

			try {
				deque.addAll(-1, testCollection);
				fail("Expected IndexOutOfBoundsException hasn't been thrown"); //$NON-NLS-1$
			} catch (IndexOutOfBoundsException e) {
				// expected
			}
			try {
				deque.addAll(deque.size() + 1, testCollection);
				fail("Expected IndexOutOfBoundsException hasn't been thrown"); //$NON-NLS-1$
			} catch (IndexOutOfBoundsException e) {
				// expected
			}
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#addFirst(Object)} with random elements.
	 */
	@Test
	public void testAddFirst() {
		Integer integer1 = -1;
		Integer integer2 = -2;
		String string1 = "a";
		String string2 = "b";
		Object object1 = new Object();
		Object object2 = new Object();

		Deque<Object> deque = new CircularArrayDeque<Object>();

		deque.addFirst(integer1);
		assertSame(1, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertEquals(integer1, deque.getLast());

		deque.addFirst(integer2);
		assertSame(2, deque.size());
		assertEquals(integer2, deque.getFirst());
		assertEquals(integer2, deque.peek());
		assertEquals(integer1, deque.getLast());

		deque.addFirst(string1);
		assertSame(3, deque.size());
		assertEquals(string1, deque.getFirst());
		assertEquals(string1, deque.peek());
		assertEquals(integer1, deque.getLast());

		deque.addFirst(string2);
		assertSame(4, deque.size());
		assertEquals(string2, deque.getFirst());
		assertEquals(string2, deque.peek());
		assertEquals(integer1, deque.getLast());

		deque.addFirst(object1);
		assertSame(5, deque.size());
		assertEquals(object1, deque.getFirst());
		assertEquals(object1, deque.peek());
		assertEquals(integer1, deque.getLast());

		deque.addFirst(object2);
		assertSame(6, deque.size());
		assertEquals(object2, deque.getFirst());
		assertEquals(object2, deque.peek());
		assertEquals(integer1, deque.getLast());

		deque.addFirst(null);
		assertSame(7, deque.size());
		assertSame(null, deque.getFirst());
		assertSame(null, deque.peek());
		assertEquals(integer1, deque.getLast());

		deque.removeFirst();
		assertSame(6, deque.size());
		assertEquals(object2, deque.getFirst());
		assertEquals(object2, deque.peek());
		assertEquals(integer1, deque.getLast());

		deque.addFirst(null);
		assertSame(7, deque.size());
		assertSame(null, deque.getFirst());
		assertSame(null, deque.peek());
		assertEquals(integer1, deque.getLast());

		// Ensure we go above capacity
		for (int i = 0; i < 100; i++) {
			String rand = getRandomString();
			while (deque.contains(rand)) {
				rand = getRandomString();
			}
			deque.addFirst(rand);
			assertSame(7 + i + 1, deque.size());
			assertEquals(rand, deque.getFirst());
			assertEquals(rand, deque.peek());
			assertSame(integer1, deque.getLast());
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#addLast(Object)} with random elements.
	 */
	@Test
	public void testAddLast() {
		Integer integer1 = -1;
		Integer integer2 = -2;
		String string1 = "a";
		String string2 = "b";
		Object object1 = new Object();
		Object object2 = new Object();

		Deque<Object> deque = new CircularArrayDeque<Object>();

		deque.addLast(integer1);
		assertSame(1, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.getLast());
		assertEquals(integer1, deque.peek());

		deque.addLast(integer2);
		assertSame(2, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertEquals(integer2, deque.getLast());

		deque.addLast(string1);
		assertSame(3, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertEquals(string1, deque.getLast());

		deque.addLast(string2);
		assertSame(4, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertEquals(string2, deque.getLast());

		deque.addLast(object1);
		assertSame(5, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertEquals(object1, deque.getLast());

		deque.addLast(object2);
		assertSame(6, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertEquals(object2, deque.getLast());

		deque.addLast(null);
		assertSame(7, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertSame(null, deque.getLast());

		deque.pop();
		assertSame(6, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertEquals(object2, deque.getLast());

		deque.addLast(null);
		assertSame(7, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertSame(null, deque.getLast());

		// Ensure we go above capacity
		for (int i = 0; i < 100; i++) {
			String rand = getRandomString();
			while (deque.contains(rand)) {
				rand = getRandomString();
			}
			deque.addLast(rand);
			assertSame(7 + i + 1, deque.size());
			assertEquals(integer1, deque.getFirst());
			assertEquals(integer1, deque.peek());
			assertSame(rand, deque.getLast());
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#add(int, Object)} with random elements.
	 */
	@Test
	public void testAddRandomAccessLeftRotate() {
		Object[] testObjects = new Object[] {"abcd", "", "*", "?", "\n", '\'', null, 4, 4.3, 5L, 4.3d, //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
				new Object() };

		for (int i = 0; i < testObjects.length; i++) {
			internalTestAddRandomAccessLeftRotate(testObjects[i]);
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#add(int, Object)} with random elements but with out of
	 * bounds indices.
	 */
	@Test
	public void testAddRandomAccessOutOfBounds() {
		Deque<Object> deque = new CircularArrayDeque<Object>();
		Object[] testObjects = new Object[] {"abcd", "", "*", "?", "\n", '\'', null, 4, 4.3, 5L, 4.3d, //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
				new Object() };

		for (int i = 0; i < testObjects.length; i++) {
			try {
				deque.add(-1, testObjects[i]);
				fail("Expected IndexOutOfBoundsException hasn't been thrown"); //$NON-NLS-1$
			} catch (IndexOutOfBoundsException e) {
				// expected
			}
			try {
				deque.add(deque.size() + 1, testObjects[i]);
				fail("Expected IndexOutOfBoundsException hasn't been thrown"); //$NON-NLS-1$
			} catch (IndexOutOfBoundsException e) {
				// expected
			}
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#add(int, Object)} with random elements.
	 */
	@Test
	public void testAddRandomAccessRightRotate() {
		Object[] testObjects = new Object[] {"abcd", "", "*", "?", "\n", '\'', null, 4, 4.3, 5L, 4.3d, //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
				new Object() };

		for (int i = 0; i < testObjects.length; i++) {
			internalTestAddRandomAccessRightRotate(testObjects[i]);
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#clear()} with random elements.
	 */
	@Test
	public void testClear() {
		Deque<Object> deque = new CircularArrayDeque<Object>();
		assertSame(0, deque.size());
		assertTrue(deque.isEmpty());
		assertEquals(16, getInternalCapacity(deque));

		deque.clear();
		assertSame(0, deque.size());
		assertTrue(deque.isEmpty());
		assertEquals(16, getInternalCapacity(deque));

		for (int i = 0; i < 100; i++) {
			String rand = getRandomString();
			while (deque.contains(rand)) {
				rand = getRandomString();
			}
			deque.offer(rand);
		}
		deque.offer(null);
		assertSame(101, deque.size());
		assertFalse(deque.isEmpty());
		int expectedCapacity = getNextPowerOfTwo(deque.size());
		assertEquals(expectedCapacity, getInternalCapacity(deque));

		deque.clear();
		assertTrue(deque.isEmpty());
		assertSame(0, deque.size());
		assertEquals(expectedCapacity, getInternalCapacity(deque));

		deque.clear();
		assertTrue(deque.isEmpty());
		assertSame(0, deque.size());
		assertEquals(expectedCapacity, getInternalCapacity(deque));
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#contains()} with random elements.
	 */
	@Test
	public void testContains() {
		Deque<Object> deque = new CircularArrayDeque<Object>();

		deque.offer(null);
		assertTrue(deque.contains(null));
		for (int i = 0; i < 100; i++) {
			String rand = getRandomString();
			while (deque.contains(rand)) {
				rand = getRandomString();
			}
			deque.offer(rand);
			assertTrue(deque.contains(null));
			assertTrue(deque.contains(rand));
		}

		Deque<Object> dequeCopy = new CircularArrayDeque<Object>(deque);
		assertTrue(deque.contains(null));
		for (Object o : dequeCopy) {
			assertTrue(deque.contains(o));
		}

		deque.clear();
		assertFalse(deque.contains(null));
		for (Object o : dequeCopy) {
			assertFalse(deque.contains(o));
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#containsAll()} with random elements.
	 */
	@Test
	public void testContainsAll() {
		Deque<Object> deque = new CircularArrayDeque<Object>();

		Collection<Object> objects1 = new ArrayList<Object>();
		objects1.add(null);
		objects1.addAll(randomStringDequeNotIn(40, Collections.emptySet()));
		objects1.add(null);
		assertSame(42, objects1.size());

		assertFalse(deque.containsAll(objects1));

		deque.addAll(objects1);
		assertSame(42, deque.size());
		assertTrue(deque.containsAll(objects1));

		Collection<Object> objects2 = new ArrayList<Object>();
		objects2.add(null);
		objects2.addAll(randomStringSetNotIn(40, objects1));
		objects2.add(null);
		assertSame(42, objects2.size());

		assertFalse(deque.containsAll(objects2));

		deque.addAll(objects2);
		assertSame(objects1.size() + objects2.size(), deque.size());
		assertTrue(deque.containsAll(objects1));
		assertTrue(deque.containsAll(objects2));

		deque.clear();
		assertFalse(deque.containsAll(objects1));
		assertFalse(deque.containsAll(objects2));
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#element()} with random elements.
	 */
	@Test
	public void testElement() {
		Deque<Object> deque = new CircularArrayDeque<Object>();

		try {
			deque.element();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$
		} catch (NoSuchElementException e) {
			// expected
		}

		deque.offer(null);
		assertSame(null, deque.element());
		for (int i = 0; i < 20; i++) {
			String rand = getRandomString();
			while (deque.contains(rand)) {
				rand = getRandomString();
			}
			deque.offer(rand);
			assertSame(null, deque.element());
		}
		List<Object> lastAdded = new ArrayList<Object>();
		for (int i = 0; i < 20; i++) {
			String rand = getRandomString();
			while (deque.contains(rand)) {
				rand = getRandomString();
			}
			deque.addFirst(rand);
			lastAdded.add(rand);
			assertEquals(rand, deque.element());
		}
		for (int i = 0; i < 20; i++) {
			deque.removeFirst();
			if (i < 19) {
				assertEquals(lastAdded.get(lastAdded.size() - i - 2), deque.element());
			} else {
				assertSame(null, deque.element());
			}
		}

		deque.clear();
		try {
			deque.element();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$
		} catch (NoSuchElementException e) {
			// expected
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#equals()} with random elements.
	 */
	@Test
	public void testEquals() {
		Deque<Object> deque1 = new CircularArrayDeque<Object>();
		Deque<Object> deque2 = new CircularArrayDeque<Object>();

		Collection<Object> objects1 = new ArrayList<Object>();
		objects1.add(null);
		objects1.addAll(randomStringDequeNotIn(40, Collections.emptySet()));
		objects1.add(null);
		assertSame(42, objects1.size());

		deque1.addAll(objects1);
		deque2.addAll(objects1);

		Deque<Object> deque3 = new CircularArrayDeque<Object>(deque1);

		assertTrue(deque1.equals(deque2));
		assertTrue(deque1.equals(deque3));
		assertTrue(deque2.equals(deque1));
		assertTrue(deque2.equals(deque3));
		assertTrue(deque3.equals(deque1));
		assertTrue(deque3.equals(deque2));

		for (int i = 0; i < 100; i++) {
			String rand = getRandomString();
			while (deque1.contains(rand)) {
				rand = getRandomString();
			}
			deque1.offer(rand);
			deque2.offer(rand);
		}
		assertTrue(deque1.equals(deque2));
		assertFalse(deque1.equals(deque3));
		assertTrue(deque2.equals(deque1));
		assertFalse(deque2.equals(deque3));
		assertFalse(deque3.equals(deque1));
		assertFalse(deque3.equals(deque2));

		Object removed = deque1.pop();
		assertFalse(deque1.equals(deque2));
		assertFalse(deque1.equals(deque3));
		assertFalse(deque2.equals(deque1));
		assertFalse(deque2.equals(deque3));
		assertFalse(deque3.equals(deque1));
		assertFalse(deque3.equals(deque2));

		deque1.addFirst(removed);
		assertFalse(deque1.equals(deque2));
		assertFalse(deque1.equals(deque3));
		assertFalse(deque2.equals(deque1));
		assertFalse(deque2.equals(deque3));
		assertFalse(deque3.equals(deque1));
		assertFalse(deque3.equals(deque2));

		deque1.removeFirst();
		deque2.pop();
		assertTrue(deque1.equals(deque2));
		assertFalse(deque1.equals(deque3));
		assertTrue(deque2.equals(deque1));
		assertFalse(deque2.equals(deque3));
		assertFalse(deque3.equals(deque1));
		assertFalse(deque3.equals(deque2));

		deque1.offer(removed);
		deque2.offer(removed);
		assertTrue(deque1.equals(deque2));
		assertFalse(deque1.equals(deque3));
		assertTrue(deque2.equals(deque1));
		assertFalse(deque2.equals(deque3));
		assertFalse(deque3.equals(deque1));
		assertFalse(deque3.equals(deque2));
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#get(int))} with random indices.
	 */
	@Test
	public void testGet() {
		Deque<Object> deque = new CircularArrayDeque<Object>();
		List<Object> objects = new ArrayList<Object>();
		int max = 100000;

		try {
			deque.get(0);
			fail("Expected IndexOutOfBoundsException hasn't been thrown"); //$NON-NLS-1$
		} catch (IndexOutOfBoundsException e) {
			// expected
		}

		for (int i = 0; i < max; i++) {
			String rand = getRandomString();
			while (deque.contains(rand)) {
				rand = getRandomString();
			}
			deque.add(rand);
			objects.add(rand);
		}

		try {
			deque.get(-1);
			fail("Expected IndexOutOfBoundsException hasn't been thrown"); //$NON-NLS-1$
		} catch (IndexOutOfBoundsException e) {
			// expected
		}

		for (int i = 0; i < max; i++) {
			assertEquals(objects.get(i), deque.get(i));
			assertEquals(objects.get(max - 1 - i), deque.get(max - 1 - i));
		}

		try {
			deque.get(deque.size());
			fail("Expected IndexOutOfBoundsException hasn't been thrown"); //$NON-NLS-1$
		} catch (IndexOutOfBoundsException e) {
			// expected
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#getFirst()} with random elements.
	 */
	@Test
	public void testGetFirst() {
		Deque<Object> deque = new CircularArrayDeque<Object>();

		try {
			deque.getFirst();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$
		} catch (NoSuchElementException e) {
			// expected
		}

		deque.offer(null);
		assertSame(null, deque.getFirst());
		for (int i = 0; i < 20; i++) {
			String rand = getRandomString();
			while (deque.contains(rand)) {
				rand = getRandomString();
			}
			deque.offer(rand);
			assertSame(null, deque.getFirst());
		}
		List<Object> lastAdded = new ArrayList<Object>();
		for (int i = 0; i < 20; i++) {
			String rand = getRandomString();
			while (deque.contains(rand)) {
				rand = getRandomString();
			}
			deque.addFirst(rand);
			lastAdded.add(rand);
			assertEquals(rand, deque.getFirst());
		}
		for (int i = 0; i < 20; i++) {
			deque.removeFirst();
			if (i < 19) {
				assertEquals(lastAdded.get(lastAdded.size() - i - 2), deque.getFirst());
			} else {
				assertSame(null, deque.getFirst());
			}
		}

		deque.clear();
		try {
			deque.getFirst();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$
		} catch (NoSuchElementException e) {
			// expected
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#getLast()} with random elements.
	 */
	@Test
	public void testGetLast() {
		Deque<Object> deque = new CircularArrayDeque<Object>();

		try {
			deque.getLast();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$
		} catch (NoSuchElementException e) {
			// expected
		}

		deque.offer(null);
		assertSame(null, deque.getLast());
		List<Object> lastAdded = new ArrayList<Object>();
		for (int i = 0; i < 20; i++) {
			String rand = getRandomString();
			while (deque.contains(rand)) {
				rand = getRandomString();
			}
			deque.offer(rand);
			lastAdded.add(rand);
			assertEquals(rand, deque.getLast());
		}
		for (int i = 0; i < 20; i++) {
			String rand = getRandomString();
			while (deque.contains(rand)) {
				rand = getRandomString();
			}
			deque.addFirst(rand);
			assertEquals(lastAdded.get(lastAdded.size() - 1), deque.getLast());
		}
		for (int i = 0; i < 20; i++) {
			deque.removeLast();
			if (i < 19) {
				assertEquals(lastAdded.get(lastAdded.size() - i - 2), deque.getLast());
			} else {
				assertSame(null, deque.getLast());
			}
		}

		deque.clear();
		try {
			deque.getLast();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$
		} catch (NoSuchElementException e) {
			// expected
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#hashCode()} with random elements.
	 */
	@Test
	public void testHashCode() {
		Deque<Object> deque1 = new CircularArrayDeque<Object>();
		Deque<Object> deque2 = new CircularArrayDeque<Object>();

		Collection<Object> objects1 = new ArrayList<Object>();
		objects1.add(null);
		objects1.addAll(randomStringDequeNotIn(40, Collections.emptySet()));
		objects1.add(null);
		assertSame(42, objects1.size());

		Collection<Object> objects2 = new ArrayList<Object>();
		objects2.add(null);
		objects2.addAll(randomStringSetNotIn(40, objects1));
		objects2.add(null);
		assertSame(42, objects2.size());

		deque1.addAll(objects1);
		deque2.addAll(objects1);

		Deque<Object> deque3 = new CircularArrayDeque<Object>(deque1);

		assertEquals(deque1.hashCode(), deque2.hashCode());
		assertEquals(deque1.hashCode(), deque3.hashCode());
		assertEquals(deque2.hashCode(), deque1.hashCode());
		assertEquals(deque2.hashCode(), deque3.hashCode());
		assertEquals(deque3.hashCode(), deque1.hashCode());
		assertEquals(deque3.hashCode(), deque2.hashCode());

		for (int i = 0; i < 100; i++) {
			String rand = getRandomString();
			while (deque1.contains(rand)) {
				rand = getRandomString();
			}
			deque1.offer(rand);
			deque2.offer(rand);
		}
		assertEquals(deque1.hashCode(), deque2.hashCode());
		assertFalse(deque1.hashCode() == deque3.hashCode());
		assertEquals(deque2.hashCode(), deque1.hashCode());
		assertFalse(deque2.hashCode() == deque3.hashCode());
		assertFalse(deque3.hashCode() == deque1.hashCode());
		assertFalse(deque3.hashCode() == deque2.hashCode());

		Object removed = deque1.pop();
		assertFalse(deque1.hashCode() == deque2.hashCode());
		assertFalse(deque1.hashCode() == deque3.hashCode());
		assertFalse(deque2.hashCode() == deque1.hashCode());
		assertFalse(deque2.hashCode() == deque3.hashCode());
		assertFalse(deque3.hashCode() == deque1.hashCode());
		assertFalse(deque3.hashCode() == deque2.hashCode());

		deque1.addFirst(removed);
		assertFalse(deque1.hashCode() == deque2.hashCode());
		assertFalse(deque1.hashCode() == deque3.hashCode());
		assertFalse(deque2.hashCode() == deque1.hashCode());
		assertFalse(deque2.hashCode() == deque3.hashCode());
		assertFalse(deque3.hashCode() == deque1.hashCode());
		assertFalse(deque3.hashCode() == deque2.hashCode());

		deque1.removeFirst();
		deque2.pop();
		assertEquals(deque1.hashCode(), deque2.hashCode());
		assertFalse(deque1.hashCode() == deque3.hashCode());
		assertEquals(deque2.hashCode(), deque1.hashCode());
		assertFalse(deque2.hashCode() == deque3.hashCode());
		assertFalse(deque3.hashCode() == deque1.hashCode());
		assertFalse(deque3.hashCode() == deque2.hashCode());

		deque1.offer(removed);
		deque2.offer(removed);
		assertEquals(deque1.hashCode(), deque2.hashCode());
		assertFalse(deque1.hashCode() == deque3.hashCode());
		assertEquals(deque2.hashCode(), deque1.hashCode());
		assertFalse(deque2.hashCode() == deque3.hashCode());
		assertFalse(deque3.hashCode() == deque1.hashCode());
		assertFalse(deque3.hashCode() == deque2.hashCode());
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#indexOf(Object)} with random elements.
	 */
	@Test
	public void testIndexOf() {
		Object[] testObjects = new Object[] {"abcd", "", "*", "?", "\n", '\'', null, 4, 4.3, 5L, 5.3d, //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
				new Object() };

		Deque<Object> deque = new CircularArrayDeque<Object>();
		for (int i = 0; i < testObjects.length; i++) {
			assertEquals(Integer.valueOf(-1), Integer.valueOf(deque.indexOf(testObjects[i])));
		}

		for (Object o : testObjects) {
			deque.offer(o);
		}

		Object[] expected = new Object[16];
		for (int i = 0; i < testObjects.length; i++) {
			expected[i] = testObjects[i];
			assertEquals(Integer.valueOf(i), Integer.valueOf(deque.indexOf(testObjects[i])));
		}
		assertEqualContent(expected, getInternalArray(deque));

		deque.clear();
		for (int i = 0; i < testObjects.length; i++) {
			assertEquals(Integer.valueOf(-1), Integer.valueOf(deque.indexOf(testObjects[i])));
		}

		deque = new CircularArrayDeque<Object>();
		deque.offer("a"); //$NON-NLS-1$
		for (Object o : testObjects) {
			deque.offer(o);
		}
		deque.removeFirst();
		int offset = 1;
		expected = new Object[16];
		for (int i = 0; i < testObjects.length; i++) {
			expected[i + offset] = testObjects[i];
			assertEquals(Integer.valueOf(i), Integer.valueOf(deque.indexOf(testObjects[i])));
		}
		assertEqualContent(expected, getInternalArray(deque));

		deque = new CircularArrayDeque<Object>();
		for (int i = 0; i < 10; i++) {
			deque.offer("a"); //$NON-NLS-1$			
		}
		for (int i = 0; i < 9; i++) {
			deque.removeFirst();
		}
		for (Object o : testObjects) {
			deque.offer(o);
		}
		deque.removeFirst();
		offset = 10;
		expected = new Object[16];
		for (int i = 0; i < testObjects.length; i++) {
			expected[(i + offset) & (expected.length - 1)] = testObjects[i];
			assertEquals(Integer.valueOf(i), Integer.valueOf(deque.indexOf(testObjects[i])));
		}
		assertEqualContent(expected, getInternalArray(deque));

		deque = new CircularArrayDeque<Object>();
		for (Object o : testObjects) {
			deque.offer(o);
		}
		for (Object o : testObjects) {
			deque.offer(o);
		}
		expected = new Object[getNextPowerOfTwo(testObjects.length * 2)];
		for (int i = 0; i < testObjects.length; i++) {
			expected[i] = testObjects[i];
			expected[i + testObjects.length] = testObjects[i];
			assertEquals(Integer.valueOf(i), Integer.valueOf(deque.indexOf(testObjects[i])));
			assertEquals(Integer.valueOf(i + testObjects.length), Integer.valueOf(deque
					.lastIndexOf(testObjects[i])));
		}
		assertEqualContent(expected, getInternalArray(deque));
	}

	/**
	 * Tests that the copy constructor of the Deque creates a deque with all objects of the initial
	 * collection.
	 */
	@Test
	public void testInstantiationCopy() {
		Collection<Integer> listInt10 = randomIntegerListNotIn(10, Collections.emptySet());
		Collection<String> setString20 = randomStringSetNotIn(20, Collections.emptySet());
		Collection<String> dequeString40 = randomStringDequeNotIn(40, setString20);

		Deque<Object> deque = new CircularArrayDeque<Object>(listInt10);
		assertFalse(deque.isEmpty());
		assertEquals(listInt10.size(), deque.size());
		assertTrue(deque.containsAll(listInt10));
		assertEquals(getNextPowerOfTwo(listInt10.size()), getInternalCapacity(deque));

		deque = new CircularArrayDeque<Object>(setString20);
		assertFalse(deque.isEmpty());
		assertEquals(setString20.size(), deque.size());
		assertTrue(deque.containsAll(setString20));
		assertEquals(getNextPowerOfTwo(setString20.size()), getInternalCapacity(deque));

		deque = new CircularArrayDeque<Object>(dequeString40);
		assertFalse(deque.isEmpty());
		assertEquals(dequeString40.size(), deque.size());
		assertTrue(deque.containsAll(dequeString40));
		assertEquals(getNextPowerOfTwo(dequeString40.size()), getInternalCapacity(deque));
	}

	/**
	 * Tests the two constructors of the Deque that initialize an empty deque.
	 */
	@Test
	public void testInstantiationEmpty() {
		Deque<Object> deque = new CircularArrayDeque<Object>();
		assertTrue(deque.isEmpty());
		assertSame(0, deque.size());
		// Default capacity is 16
		assertEquals(16, getInternalCapacity(deque));

		deque = new CircularArrayDeque<Object>((1 << 10) - 1);
		assertTrue(deque.isEmpty());
		assertSame(0, deque.size());
		assertEquals(1 << 10, getInternalCapacity(deque));

		deque = new CircularArrayDeque<Object>(1 << 31);
		assertTrue(deque.isEmpty());
		assertSame(0, deque.size());
		assertEquals(4, getInternalCapacity(deque));

		deque = new CircularArrayDeque<Object>(-1);
		assertTrue(deque.isEmpty());
		assertSame(0, deque.size());
		assertEquals(4, getInternalCapacity(deque));
	}

	/**
	 * Tests the constructors of the Deque with out of bounds or erroneous values.
	 */
	@Test
	public void testInstantiationError() {
		try {
			new CircularArrayDeque<Object>(Integer.MAX_VALUE);
			fail("Expected IndexOutOfBoundsException hasn't been thrown"); //$NON-NLS-1$
		} catch (IndexOutOfBoundsException e) {
			// Expected
		}
		try {
			/*
			 * The last possible size for our internal array is 2^30, trying to hold that much elements will
			 * yield a size of -1, which is invalid.
			 */
			new CircularArrayDeque<Object>((1 << 30) + 1);
			fail("Expected IndexOutOfBoundsException hasn't been thrown"); //$NON-NLS-1$
		} catch (IndexOutOfBoundsException e) {
			// Expected
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#isEmpty()} with random elements.
	 */
	@Test
	public void testIsEmpty() {
		Deque<Object> deque = new CircularArrayDeque<Object>();
		assertTrue(deque.isEmpty());

		deque.offer(null);
		assertFalse(deque.isEmpty());

		for (int i = 0; i < 100; i++) {
			String rand = getRandomString();
			while (deque.contains(rand)) {
				rand = getRandomString();
			}
			deque.offer(rand);
			assertFalse(deque.isEmpty());
		}
		for (int i = 0; i < 100; i++) {
			deque.pop();
			assertFalse(deque.isEmpty());
		}

		deque.pop();
		assertTrue(deque.isEmpty());

		for (int i = 0; i < 100; i++) {
			String rand = getRandomString();
			while (deque.contains(rand)) {
				rand = getRandomString();
			}
			deque.offer(rand);
			assertFalse(deque.isEmpty());
		}

		deque.clear();
		assertTrue(deque.isEmpty());
	}

	/**
	 * Tests the behavior of the serialization and deserialization support of the {@link CircularArrayDeque}.
	 * FIXME test deserialization from file to ensure we do not break support of older serialized deques.
	 */
	@Test
	public void testIsSerializable() {
		Collection<Object> emptyCollection = Collections.emptyList();
		Collection<Integer> listInt10 = randomIntegerListNotIn(10, Collections.emptySet());
		Collection<String> setString20 = randomStringSetNotIn(20, Collections.emptySet());
		Collection<String> dequeString40 = randomStringDequeNotIn(40, setString20);
		Collection<Object> duplicatesList = new ArrayList<Object>();
		for (int i = 0; i < 40; i++) {
			int dupe = i / 2;
			duplicatesList.add(Integer.valueOf(dupe));
			duplicatesList.add(String.valueOf(dupe));
		}
		duplicatesList.add(null);
		duplicatesList.add(null);

		Deque<Object> deque = new CircularArrayDeque<Object>();

		byte[] serialized = writeDeque(deque);
		assertTrue(serialized.length > 0);
		Deque<Object> read = readDeque(serialized);
		assertNotNull(read);
		assertEquals(deque, read);

		deque.addAll(emptyCollection);
		serialized = writeDeque(deque);
		assertTrue(serialized.length > 0);
		read = readDeque(serialized);
		assertNotNull(read);
		assertEquals(deque, read);

		deque.addAll(listInt10);
		serialized = writeDeque(deque);
		assertTrue(serialized.length > 0);
		read = readDeque(serialized);
		assertNotNull(read);
		assertEquals(deque, read);

		deque.addAll(setString20);
		serialized = writeDeque(deque);
		assertTrue(serialized.length > 0);
		read = readDeque(serialized);
		assertNotNull(read);
		assertEquals(deque, read);

		deque.addAll(dequeString40);
		serialized = writeDeque(deque);
		assertTrue(serialized.length > 0);
		read = readDeque(serialized);
		assertNotNull(read);
		assertEquals(deque, read);

		deque.addAll(duplicatesList);
		serialized = writeDeque(deque);
		assertTrue(serialized.length > 0);
		read = readDeque(serialized);
		assertNotNull(read);
		assertEquals(deque, read);
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#iterator()} with random elements.
	 */
	@Test
	public void testIterator() {
		Collection<Integer> listInt10 = randomIntegerListNotIn(10, Collections.emptySet());
		Collection<String> setString20 = randomStringSetNotIn(20, Collections.emptySet());
		Collection<String> dequeString40 = randomStringDequeNotIn(40, setString20);

		Deque<Object> deque = new CircularArrayDeque<Object>();

		Iterator<Object> emptyIterator = deque.iterator();
		assertFalse(emptyIterator.hasNext());
		try {
			emptyIterator.next();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$
		} catch (NoSuchElementException e) {
			// expected
		}
		try {
			emptyIterator.remove();
			fail("Expected IllegalStateException hasn't been thrown"); //$NON-NLS-1$
		} catch (IllegalStateException e) {
			// expected
		}

		Iterator<Object> concurrentIterator = deque.iterator();
		deque.addFirst(null);
		try {
			concurrentIterator.next();
			fail("Expected ConcurrentModificationException hasn't been thrown"); //$NON-NLS-1$
		} catch (ConcurrentModificationException e) {
			// expected
		}
		try {
			concurrentIterator.remove();
			fail("Expected IllegalStateException hasn't been thrown"); //$NON-NLS-1$
		} catch (IllegalStateException e) {
			// expected
		}
		deque.pop();

		concurrentIterator = deque.iterator();
		deque.addLast(null);
		try {
			concurrentIterator.next();
			fail("Expected ConcurrentModificationException hasn't been thrown"); //$NON-NLS-1$
		} catch (ConcurrentModificationException e) {
			// expected
		}
		try {
			concurrentIterator.remove();
			fail("Expected IllegalStateException hasn't been thrown"); //$NON-NLS-1$
		} catch (IllegalStateException e) {
			// expected
		}
		deque.pop();

		deque.addLast(null);
		concurrentIterator = deque.iterator();
		assertNull(concurrentIterator.next());
		deque.addLast(null);
		try {
			concurrentIterator.remove();
			fail("Expected ConcurrentModificationException hasn't been thrown"); //$NON-NLS-1$
		} catch (ConcurrentModificationException e) {
			// expected
		}
		deque.clear();

		deque.addAll(listInt10);
		deque.addAll(setString20);
		deque.addAll(dequeString40);

		Iterator<Integer> listIterator = listInt10.iterator();
		Iterator<String> setIterator = setString20.iterator();
		Iterator<String> dequeIterator = dequeString40.iterator();
		Iterator<Object> containedValues = deque.iterator();
		while (listIterator.hasNext()) {
			assertEquals(listIterator.next(), containedValues.next());
		}
		assertTrue(containedValues.hasNext());
		while (setIterator.hasNext()) {
			assertEquals(setIterator.next(), containedValues.next());
		}
		assertTrue(containedValues.hasNext());
		while (dequeIterator.hasNext()) {
			assertEquals(dequeIterator.next(), containedValues.next());
		}
		assertFalse(containedValues.hasNext());

		for (@SuppressWarnings("unused")
		Integer val : listInt10) {
			deque.removeFirst();
		}
		deque.addAll(listInt10);

		listIterator = listInt10.iterator();
		setIterator = setString20.iterator();
		dequeIterator = dequeString40.iterator();
		containedValues = deque.iterator();
		while (setIterator.hasNext()) {
			assertEquals(setIterator.next(), containedValues.next());
		}
		assertTrue(containedValues.hasNext());
		while (dequeIterator.hasNext()) {
			assertEquals(dequeIterator.next(), containedValues.next());
		}
		assertTrue(containedValues.hasNext());
		while (listIterator.hasNext()) {
			assertEquals(listIterator.next(), containedValues.next());
		}
		assertFalse(containedValues.hasNext());
	}

	/**
	 * Tests the removal of elements of the Deque through the iterator.remove method.
	 */
	@Test
	public void testIteratorRemove() {
		Collection<Integer> listInt10 = randomIntegerListNotIn(10, Collections.emptySet());
		Collection<String> setString20 = randomStringSetNotIn(20, Collections.emptySet());
		Collection<String> dequeString40 = randomStringDequeNotIn(40, setString20);

		Deque<Object> deque = new CircularArrayDeque<Object>();

		Iterator<Object> emptyIterator = deque.iterator();
		assertFalse(emptyIterator.hasNext());
		try {
			emptyIterator.next();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$
		} catch (NoSuchElementException e) {
			// expected
		}
		try {
			emptyIterator.remove();
			fail("Expected IllegalStateException hasn't been thrown"); //$NON-NLS-1$
		} catch (IllegalStateException e) {
			// expected
		}

		Iterator<Object> concurrentIterator = deque.iterator();
		deque.addFirst(null);
		try {
			concurrentIterator.next();
			fail("Expected ConcurrentModificationException hasn't been thrown"); //$NON-NLS-1$
		} catch (ConcurrentModificationException e) {
			// expected
		}
		try {
			concurrentIterator.remove();
			fail("Expected IllegalStateException hasn't been thrown"); //$NON-NLS-1$
		} catch (IllegalStateException e) {
			// expected
		}
		deque.pop();

		concurrentIterator = deque.iterator();
		deque.addLast(null);
		try {
			concurrentIterator.next();
			fail("Expected ConcurrentModificationException hasn't been thrown"); //$NON-NLS-1$
		} catch (ConcurrentModificationException e) {
			// expected
		}
		try {
			concurrentIterator.remove();
			fail("Expected IllegalStateException hasn't been thrown"); //$NON-NLS-1$
		} catch (IllegalStateException e) {
			// expected
		}
		deque.pop();

		deque.addAll(listInt10);
		deque.addAll(setString20);
		deque.addAll(dequeString40);

		Iterator<Integer> listIterator = listInt10.iterator();
		Iterator<String> setIterator = setString20.iterator();
		Iterator<String> dequeIterator = dequeString40.iterator();
		Iterator<Object> containedValues = deque.iterator();
		while (listIterator.hasNext()) {
			assertEquals(listIterator.next(), containedValues.next());
			containedValues.remove();
		}
		assertTrue(containedValues.hasNext());
		while (setIterator.hasNext()) {
			assertEquals(setIterator.next(), containedValues.next());
			containedValues.remove();
		}
		assertTrue(containedValues.hasNext());
		while (dequeIterator.hasNext()) {
			assertEquals(dequeIterator.next(), containedValues.next());
			containedValues.remove();
		}
		assertFalse(containedValues.hasNext());
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#lastIndexOf(Object)} with random elements.
	 */
	@Test
	public void testLastIndexOf() {
		Object[] testObjects = new Object[] {"abcd", "", "*", "?", "\n", '\'', null, 4, 4.3, 5L, 5.3d, //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
				new Object() };

		Deque<Object> deque = new CircularArrayDeque<Object>();
		for (int i = 0; i < testObjects.length; i++) {
			assertEquals(Integer.valueOf(-1), Integer.valueOf(deque.lastIndexOf(testObjects[i])));
		}

		for (Object o : testObjects) {
			deque.offer(o);
		}

		Object[] expected = new Object[16];
		for (int i = 0; i < testObjects.length; i++) {
			expected[i] = testObjects[i];
			assertEquals(Integer.valueOf(i), Integer.valueOf(deque.lastIndexOf(testObjects[i])));
		}
		assertEqualContent(expected, getInternalArray(deque));

		deque.clear();
		for (int i = 0; i < testObjects.length; i++) {
			assertEquals(Integer.valueOf(-1), Integer.valueOf(deque.lastIndexOf(testObjects[i])));
		}

		deque = new CircularArrayDeque<Object>();
		deque.offer("a"); //$NON-NLS-1$
		for (Object o : testObjects) {
			deque.offer(o);
		}
		deque.removeFirst();
		int offset = 1;
		expected = new Object[16];
		for (int i = 0; i < testObjects.length; i++) {
			expected[i + offset] = testObjects[i];
			assertEquals(Integer.valueOf(i), Integer.valueOf(deque.lastIndexOf(testObjects[i])));
		}
		assertEqualContent(expected, getInternalArray(deque));

		deque = new CircularArrayDeque<Object>();
		for (int i = 0; i < 10; i++) {
			deque.offer("a"); //$NON-NLS-1$			
		}
		for (int i = 0; i < 9; i++) {
			deque.removeFirst();
		}
		for (Object o : testObjects) {
			deque.offer(o);
		}
		deque.removeFirst();
		offset = 10;
		expected = new Object[16];
		for (int i = 0; i < testObjects.length; i++) {
			expected[(i + offset) & (expected.length - 1)] = testObjects[i];
			assertEquals(Integer.valueOf(i), Integer.valueOf(deque.lastIndexOf(testObjects[i])));
		}
		assertEqualContent(expected, getInternalArray(deque));

		deque = new CircularArrayDeque<Object>();
		for (Object o : testObjects) {
			deque.offer(o);
		}
		for (Object o : testObjects) {
			deque.offer(o);
		}
		expected = new Object[getNextPowerOfTwo(testObjects.length * 2)];
		for (int i = 0; i < testObjects.length; i++) {
			expected[i] = testObjects[i];
			expected[i + testObjects.length] = testObjects[i];
			assertEquals(Integer.valueOf(i), Integer.valueOf(deque.indexOf(testObjects[i])));
			assertEquals(Integer.valueOf(i + testObjects.length), Integer.valueOf(deque
					.lastIndexOf(testObjects[i])));
		}
		assertEqualContent(expected, getInternalArray(deque));
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#listIterator()} with random elements.
	 */
	@Test
	public void testListIterator() {
		Deque<Object> deque = new CircularArrayDeque<Object>();

		ListIterator<Object> emptyIterator = deque.listIterator();
		assertFalse(emptyIterator.hasNext());
		assertFalse(emptyIterator.hasPrevious());
		assertSame(0, emptyIterator.nextIndex());
		assertSame(-1, emptyIterator.previousIndex());
		try {
			emptyIterator.next();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$
		} catch (NoSuchElementException e) {
			// expected
		}
		try {
			emptyIterator.previous();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$
		} catch (NoSuchElementException e) {
			// expected
		}
		try {
			emptyIterator.set(new Object());
			fail("Expected IllegalStateException hasn't been thrown"); //$NON-NLS-1$
		} catch (IllegalStateException e) {
			// expected
		}
		try {
			emptyIterator.remove();
			fail("Expected IllegalStateException hasn't been thrown"); //$NON-NLS-1$
		} catch (IllegalStateException e) {
			// expected
		}
		Object a = new Object();
		emptyIterator.add(a);
		assertSame(1, deque.size());
		assertFalse(emptyIterator.hasNext());
		assertTrue(emptyIterator.hasPrevious());
		assertSame(1, emptyIterator.nextIndex());
		assertSame(0, emptyIterator.previousIndex());

		assertEquals(a, emptyIterator.previous());
		assertTrue(emptyIterator.hasNext());
		assertFalse(emptyIterator.hasPrevious());
		assertSame(0, emptyIterator.nextIndex());
		assertSame(-1, emptyIterator.previousIndex());

		assertEquals(a, emptyIterator.next());
		assertFalse(emptyIterator.hasNext());
		assertTrue(emptyIterator.hasPrevious());
		assertSame(1, emptyIterator.nextIndex());
		assertSame(0, emptyIterator.previousIndex());

		Object b = new Object();
		emptyIterator.add(b);
		assertSame(2, deque.size());
		assertFalse(emptyIterator.hasNext());
		assertTrue(emptyIterator.hasPrevious());
		assertSame(2, emptyIterator.nextIndex());
		assertSame(1, emptyIterator.previousIndex());

		assertEquals(b, emptyIterator.previous());
		assertTrue(emptyIterator.hasNext());
		assertTrue(emptyIterator.hasPrevious());
		assertSame(1, emptyIterator.nextIndex());
		assertSame(0, emptyIterator.previousIndex());

		Object c = new Object();
		emptyIterator.set(c);
		assertSame(2, deque.size());
		assertTrue(emptyIterator.hasNext());
		assertTrue(emptyIterator.hasPrevious());
		assertSame(1, emptyIterator.nextIndex());
		assertSame(0, emptyIterator.previousIndex());

		assertEquals(c, emptyIterator.next());
		assertFalse(emptyIterator.hasNext());
		assertTrue(emptyIterator.hasPrevious());
		assertSame(2, emptyIterator.nextIndex());
		assertSame(1, emptyIterator.previousIndex());

		assertEquals(c, emptyIterator.previous());
		assertTrue(emptyIterator.hasNext());
		assertTrue(emptyIterator.hasPrevious());
		assertSame(1, emptyIterator.nextIndex());
		assertSame(0, emptyIterator.previousIndex());

		emptyIterator.remove();
		assertSame(1, deque.size());
		assertFalse(emptyIterator.hasNext());
		assertTrue(emptyIterator.hasPrevious());
		assertSame(1, emptyIterator.nextIndex());
		assertSame(0, emptyIterator.previousIndex());

		try {
			emptyIterator.next();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$
		} catch (NoSuchElementException e) {
			// expected
		}

		assertEquals(a, emptyIterator.previous());
		assertTrue(emptyIterator.hasNext());
		assertFalse(emptyIterator.hasPrevious());
		assertSame(0, emptyIterator.nextIndex());
		assertSame(-1, emptyIterator.previousIndex());

		emptyIterator.remove();
		assertSame(0, deque.size());
		assertFalse(emptyIterator.hasNext());
		assertFalse(emptyIterator.hasPrevious());
		assertSame(0, emptyIterator.nextIndex());
		assertSame(-1, emptyIterator.previousIndex());

		try {
			emptyIterator.next();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$
		} catch (NoSuchElementException e) {
			// expected
		}
		try {
			emptyIterator.previous();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$
		} catch (NoSuchElementException e) {
			// expected
		}
		try {
			emptyIterator.set(new Object());
			fail("Expected IllegalStateException hasn't been thrown"); //$NON-NLS-1$
		} catch (IllegalStateException e) {
			// expected
		}
		try {
			emptyIterator.remove();
			fail("Expected IllegalStateException hasn't been thrown"); //$NON-NLS-1$
		} catch (IllegalStateException e) {
			// expected
		}

		ListIterator<Object> concurrentIterator = deque.listIterator();
		deque.addFirst(null);
		try {
			concurrentIterator.next();
			fail("Expected ConcurrentModificationException hasn't been thrown"); //$NON-NLS-1$
		} catch (ConcurrentModificationException e) {
			// expected
		}
		try {
			concurrentIterator.previous();
			fail("Expected ConcurrentModificationException hasn't been thrown"); //$NON-NLS-1$
		} catch (ConcurrentModificationException e) {
			// expected
		}
		try {
			concurrentIterator.add(new Object());
			fail("Expected ConcurrentModificationException hasn't been thrown"); //$NON-NLS-1$
		} catch (ConcurrentModificationException e) {
			// expected
		}
		try {
			concurrentIterator.set(new Object());
			fail("Expected IllegalStateException hasn't been thrown"); //$NON-NLS-1$
		} catch (IllegalStateException e) {
			// expected
		}
		try {
			concurrentIterator.remove();
			fail("Expected IllegalStateException hasn't been thrown"); //$NON-NLS-1$
		} catch (IllegalStateException e) {
			// expected
		}
		deque.pop();

		concurrentIterator = deque.listIterator();
		deque.addLast(null);
		try {
			concurrentIterator.next();
			fail("Expected ConcurrentModificationException hasn't been thrown"); //$NON-NLS-1$
		} catch (ConcurrentModificationException e) {
			// expected
		}
		try {
			concurrentIterator.previous();
			fail("Expected ConcurrentModificationException hasn't been thrown"); //$NON-NLS-1$
		} catch (ConcurrentModificationException e) {
			// expected
		}
		try {
			concurrentIterator.add(new Object());
			fail("Expected ConcurrentModificationException hasn't been thrown"); //$NON-NLS-1$
		} catch (ConcurrentModificationException e) {
			// expected
		}
		try {
			concurrentIterator.set(new Object());
			fail("Expected IllegalStateException hasn't been thrown"); //$NON-NLS-1$
		} catch (IllegalStateException e) {
			// expected
		}
		try {
			concurrentIterator.remove();
			fail("Expected IllegalStateException hasn't been thrown"); //$NON-NLS-1$
		} catch (IllegalStateException e) {
			// expected
		}
		deque.pop();

		deque.addLast(null);
		concurrentIterator = deque.listIterator();
		assertNull(concurrentIterator.next());
		deque.addLast(null);
		try {
			concurrentIterator.next();
			fail("Expected ConcurrentModificationException hasn't been thrown"); //$NON-NLS-1$
		} catch (ConcurrentModificationException e) {
			// expected
		}
		try {
			concurrentIterator.previous();
			fail("Expected ConcurrentModificationException hasn't been thrown"); //$NON-NLS-1$
		} catch (ConcurrentModificationException e) {
			// expected
		}
		try {
			concurrentIterator.add(new Object());
			fail("Expected ConcurrentModificationException hasn't been thrown"); //$NON-NLS-1$
		} catch (ConcurrentModificationException e) {
			// expected
		}
		try {
			concurrentIterator.set(new Object());
			fail("Expected ConcurrentModificationException hasn't been thrown"); //$NON-NLS-1$
		} catch (ConcurrentModificationException e) {
			// expected
		}
		try {
			concurrentIterator.remove();
			fail("Expected ConcurrentModificationException hasn't been thrown"); //$NON-NLS-1$
		} catch (ConcurrentModificationException e) {
			// expected
		}
		deque.clear();

		List<Integer> listInt10 = randomIntegerListNotIn(10, Collections.emptySet());
		Set<String> setString20 = randomStringSetNotIn(20, Collections.emptySet());
		List<String> dequeString40 = randomStringDequeNotIn(40, setString20);

		deque.addAll(listInt10);
		deque.addAll(setString20);
		deque.addAll(dequeString40);

		Iterator<Integer> listIterator = listInt10.iterator();
		Iterator<String> setIterator = setString20.iterator();
		Iterator<String> dequeIterator = dequeString40.iterator();
		ListIterator<Object> containedValues = deque.listIterator();
		while (listIterator.hasNext()) {
			assertEquals(listIterator.next(), containedValues.next());
		}
		assertTrue(containedValues.hasNext());
		while (setIterator.hasNext()) {
			assertEquals(setIterator.next(), containedValues.next());
		}
		assertTrue(containedValues.hasNext());
		while (dequeIterator.hasNext()) {
			assertEquals(dequeIterator.next(), containedValues.next());
		}
		assertFalse(containedValues.hasNext());
		assertTrue(containedValues.hasPrevious());
		for (int i = dequeString40.size() - 1; i >= 0 && containedValues.hasPrevious(); i--) {
			assertEquals(dequeString40.get(i), containedValues.previous());
		}
		assertTrue(containedValues.hasPrevious());
		List<Object> setCopy = new ArrayList<Object>(setString20);
		for (int i = setString20.size() - 1; i >= 0 && containedValues.hasPrevious(); i--) {
			assertEquals(setCopy.get(i), containedValues.previous());
		}
		assertTrue(containedValues.hasPrevious());
		for (int i = listInt10.size() - 1; i >= 0 && containedValues.hasPrevious(); i--) {
			assertEquals(listInt10.get(i), containedValues.previous());
		}
		assertFalse(containedValues.hasPrevious());

		for (@SuppressWarnings("unused")
		Integer val : listInt10) {
			deque.removeFirst();
		}
		deque.addAll(listInt10);

		listIterator = listInt10.iterator();
		setIterator = setString20.iterator();
		dequeIterator = dequeString40.iterator();
		containedValues = deque.listIterator();
		while (setIterator.hasNext()) {
			assertEquals(setIterator.next(), containedValues.next());
		}
		assertTrue(containedValues.hasNext());
		while (dequeIterator.hasNext()) {
			assertEquals(dequeIterator.next(), containedValues.next());
		}
		assertTrue(containedValues.hasNext());
		while (listIterator.hasNext()) {
			assertEquals(listIterator.next(), containedValues.next());
		}
		assertFalse(containedValues.hasNext());
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#listIterator(int)} with random elements.
	 */
	@Test
	public void testListIteratorStartAt() {
		Deque<Object> deque = new CircularArrayDeque<Object>();
		Object[] testObjects = new Object[] {"abcd", "", "*", "?", "\n", '\'', null, 4, 4.3, 5L, 4.3d, //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
				new Object() };

		try {
			deque.listIterator(-1);
			fail("Expected IndexOutOfBoundsException  hasn't been thrown"); //$NON-NLS-1$
		} catch (IndexOutOfBoundsException e) {
			// expected
		}
		try {
			deque.listIterator(deque.size() + 1);
			fail("Expected IndexOutOfBoundsException  hasn't been thrown"); //$NON-NLS-1$
		} catch (IndexOutOfBoundsException e) {
			// expected
		}

		for (Object o : testObjects) {
			deque.add(o);
		}
		try {
			deque.listIterator(-1);
			fail("Expected IndexOutOfBoundsException  hasn't been thrown"); //$NON-NLS-1$
		} catch (IndexOutOfBoundsException e) {
			// expected
		}

		ListIterator<Object> iterator = deque.listIterator(0);
		assertFalse(iterator.hasPrevious());
		for (Object o : testObjects) {
			assertTrue(iterator.hasNext());
			assertEquals(o, iterator.next());
		}
		assertFalse(iterator.hasNext());
		for (int i = testObjects.length - 1; i >= 0; i--) {
			assertTrue(iterator.hasPrevious());
			assertEquals(testObjects[i], iterator.previous());
		}
		assertFalse(iterator.hasPrevious());

		iterator = deque.listIterator(deque.size());
		assertFalse(iterator.hasNext());
		for (int i = testObjects.length - 1; i >= 0; i--) {
			assertTrue(iterator.hasPrevious());
			assertEquals(testObjects[i], iterator.previous());
		}
		assertFalse(iterator.hasPrevious());
		for (Object o : testObjects) {
			assertTrue(iterator.hasNext());
			assertEquals(o, iterator.next());
		}
		assertFalse(iterator.hasNext());

		try {
			deque.listIterator(deque.size() + 1);
			fail("Expected IndexOutOfBoundsException  hasn't been thrown"); //$NON-NLS-1$
		} catch (IndexOutOfBoundsException e) {
			// expected
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#offer(Object) with random elements.
	 */
	@Test
	public void testOffer() {
		Integer integer1 = -1;
		Integer integer2 = -2;
		String string1 = "a";
		String string2 = "b";
		Object object1 = new Object();
		Object object2 = new Object();

		Deque<Object> deque = new CircularArrayDeque<Object>();

		deque.offer(integer1);
		assertSame(1, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.getLast());
		assertEquals(integer1, deque.peek());

		deque.offer(integer2);
		assertSame(2, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertEquals(integer2, deque.getLast());

		deque.offer(string1);
		assertSame(3, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertEquals(string1, deque.getLast());

		deque.offer(string2);
		assertSame(4, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertEquals(string2, deque.getLast());

		deque.offer(object1);
		assertSame(5, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertEquals(object1, deque.getLast());

		deque.offer(object2);
		assertSame(6, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertEquals(object2, deque.getLast());

		deque.offer(null);
		assertSame(7, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertSame(null, deque.getLast());

		deque.pop();
		assertSame(6, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertEquals(object2, deque.getLast());

		deque.offer(null);
		assertSame(7, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertSame(null, deque.getLast());

		// Ensure we go above capacity
		for (int i = 0; i < 100; i++) {
			String rand = getRandomString();
			while (deque.contains(rand)) {
				rand = getRandomString();
			}
			deque.offer(rand);
			assertSame(7 + i + 1, deque.size());
			assertEquals(integer1, deque.getFirst());
			assertEquals(integer1, deque.peek());
			assertSame(rand, deque.getLast());
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#offerAll(Collection)} with random elements.
	 */
	@Test
	public void testOfferAll() {
		Collection<Object> emptyCollection = Collections.emptyList();
		Collection<Integer> listInt10 = randomIntegerListNotIn(10, Collections.emptySet());
		Collection<String> setString20 = randomStringSetNotIn(20, Collections.emptySet());
		Collection<String> dequeString40 = randomStringDequeNotIn(40, setString20);

		Deque<Object> deque = new CircularArrayDeque<Object>();

		deque.offerAll(listInt10);
		assertEquals(listInt10.size(), deque.size());
		assertTrue(deque.containsAll(listInt10));
		assertEquals(getNextPowerOfTwo(deque.size()), getInternalCapacity(deque));

		deque.offerAll(emptyCollection);
		assertEquals(listInt10.size(), deque.size());
		assertTrue(deque.containsAll(listInt10));
		assertEquals(getNextPowerOfTwo(deque.size()), getInternalCapacity(deque));

		deque.offerAll(setString20);
		assertEquals(listInt10.size() + setString20.size(), deque.size());
		assertTrue(deque.containsAll(listInt10));
		assertTrue(deque.containsAll(setString20));
		assertEquals(getNextPowerOfTwo(deque.size()), getInternalCapacity(deque));

		deque.offerAll(dequeString40);
		assertEquals(listInt10.size() + setString20.size() + dequeString40.size(), deque.size());
		assertTrue(deque.containsAll(listInt10));
		assertTrue(deque.containsAll(setString20));
		assertTrue(deque.containsAll(dequeString40));
		int expectedCapacity = getNextPowerOfTwo(deque.size());
		assertEquals(expectedCapacity, getInternalCapacity(deque));

		for (@SuppressWarnings("unused")
		Integer val : listInt10) {
			deque.removeFirst();
		}
		assertEquals(setString20.size() + dequeString40.size(), deque.size());
		assertFalse(deque.containsAll(listInt10));
		assertTrue(deque.containsAll(setString20));
		assertTrue(deque.containsAll(dequeString40));
		assertEquals(expectedCapacity, getInternalCapacity(deque));

		deque.offerAll(listInt10);
		assertEquals(listInt10.size() + setString20.size() + dequeString40.size(), deque.size());
		assertTrue(deque.containsAll(listInt10));
		assertTrue(deque.containsAll(setString20));
		assertTrue(deque.containsAll(dequeString40));
		assertEquals(getNextPowerOfTwo(deque.size()), getInternalCapacity(deque));

		deque.offerAll(emptyCollection);
		assertEquals(listInt10.size() + setString20.size() + dequeString40.size(), deque.size());
		assertTrue(deque.containsAll(listInt10));
		assertTrue(deque.containsAll(setString20));
		assertTrue(deque.containsAll(dequeString40));
		assertEquals(getNextPowerOfTwo(deque.size()), getInternalCapacity(deque));
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#offerFirst(Object)} with random elements.
	 */
	@Test
	public void testOfferFirst() {
		Integer integer1 = -1;
		Integer integer2 = -2;
		String string1 = "a";
		String string2 = "b";
		Object object1 = new Object();
		Object object2 = new Object();

		Deque<Object> deque = new CircularArrayDeque<Object>();

		deque.offerFirst(integer1);
		assertSame(1, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertEquals(integer1, deque.getLast());

		deque.offerFirst(integer2);
		assertSame(2, deque.size());
		assertEquals(integer2, deque.getFirst());
		assertEquals(integer2, deque.peek());
		assertEquals(integer1, deque.getLast());

		deque.offerFirst(string1);
		assertSame(3, deque.size());
		assertEquals(string1, deque.getFirst());
		assertEquals(string1, deque.peek());
		assertEquals(integer1, deque.getLast());

		deque.offerFirst(string2);
		assertSame(4, deque.size());
		assertEquals(string2, deque.getFirst());
		assertEquals(string2, deque.peek());
		assertEquals(integer1, deque.getLast());

		deque.offerFirst(object1);
		assertSame(5, deque.size());
		assertEquals(object1, deque.getFirst());
		assertEquals(object1, deque.peek());
		assertEquals(integer1, deque.getLast());

		deque.offerFirst(object2);
		assertSame(6, deque.size());
		assertEquals(object2, deque.getFirst());
		assertEquals(object2, deque.peek());
		assertEquals(integer1, deque.getLast());

		deque.offerFirst(null);
		assertSame(7, deque.size());
		assertSame(null, deque.getFirst());
		assertSame(null, deque.peek());
		assertEquals(integer1, deque.getLast());

		deque.removeFirst();
		assertSame(6, deque.size());
		assertEquals(object2, deque.getFirst());
		assertEquals(object2, deque.peek());
		assertEquals(integer1, deque.getLast());

		deque.offerFirst(null);
		assertSame(7, deque.size());
		assertSame(null, deque.getFirst());
		assertSame(null, deque.peek());
		assertEquals(integer1, deque.getLast());

		// Ensure we go above capacity
		for (int i = 0; i < 100; i++) {
			String rand = getRandomString();
			while (deque.contains(rand)) {
				rand = getRandomString();
			}
			deque.offerFirst(rand);
			assertSame(7 + i + 1, deque.size());
			assertEquals(rand, deque.getFirst());
			assertEquals(rand, deque.peek());
			assertSame(integer1, deque.getLast());
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#offerLast(Object)} with random elements.
	 */
	@Test
	public void testOfferLast() {
		Integer integer1 = -1;
		Integer integer2 = -2;
		String string1 = "a";
		String string2 = "b";
		Object object1 = new Object();
		Object object2 = new Object();

		Deque<Object> deque = new CircularArrayDeque<Object>();

		deque.offerLast(integer1);
		assertSame(1, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.getLast());
		assertEquals(integer1, deque.peek());

		deque.offerLast(integer2);
		assertSame(2, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertEquals(integer2, deque.getLast());

		deque.offerLast(string1);
		assertSame(3, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertEquals(string1, deque.getLast());

		deque.offerLast(string2);
		assertSame(4, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertEquals(string2, deque.getLast());

		deque.offerLast(object1);
		assertSame(5, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertEquals(object1, deque.getLast());

		deque.offerLast(object2);
		assertSame(6, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertEquals(object2, deque.getLast());

		deque.offerLast(null);
		assertSame(7, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertSame(null, deque.getLast());

		deque.pop();
		assertSame(6, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertEquals(object2, deque.getLast());

		deque.offerLast(null);
		assertSame(7, deque.size());
		assertEquals(integer1, deque.getFirst());
		assertEquals(integer1, deque.peek());
		assertSame(null, deque.getLast());

		// Ensure we go above capacity
		for (int i = 0; i < 100; i++) {
			String rand = getRandomString();
			while (deque.contains(rand)) {
				rand = getRandomString();
			}
			deque.offerLast(rand);
			assertSame(7 + i + 1, deque.size());
			assertEquals(integer1, deque.getFirst());
			assertEquals(integer1, deque.peek());
			assertSame(rand, deque.getLast());
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#toArray(Object[])} with random elements.
	 */
	@Test
	public void testParameterizedToArray() {
		Deque<Object> deque = new CircularArrayDeque<Object>();
		List<String> objectsFirst = randomStringListNotIn(20, Collections.emptySet());
		List<String> objectsLast = randomStringListNotIn(20, objectsFirst);

		Object[] array = deque.toArray(new Object[0]);
		assertSame(0, array.length);
		array = deque.toArray(new Object[21]);
		assertSame(21, array.length);
		for (Object o : array) {
			assertNull(o);
		}

		deque.addAll(objectsLast);
		array = deque.toArray(new Object[0]);
		assertSame(deque.size(), array.length);
		Iterator<Object> dequeIterator = deque.iterator();
		for (int i = 0; i < deque.size(); i++) {
			assertEquals(dequeIterator.next(), array[i]);
		}
		array = new String[21];
		deque.toArray(array);
		assertSame(21, array.length);
		dequeIterator = deque.iterator();
		for (int i = 0; i < deque.size(); i++) {
			assertEquals(dequeIterator.next(), array[i]);
		}
		deque.clear();

		deque.addAll(objectsLast);
		for (Object o : objectsFirst) {
			deque.addFirst(o);
		}
		array = deque.toArray(new Object[0]);
		assertSame(deque.size(), array.length);
		dequeIterator = deque.iterator();
		for (int i = 0; i < deque.size(); i++) {
			assertEquals(dequeIterator.next(), array[i]);
		}
		array = new String[41];
		deque.toArray(array);
		assertSame(41, array.length);
		dequeIterator = deque.iterator();
		for (int i = 0; i < deque.size(); i++) {
			assertEquals(dequeIterator.next(), array[i]);
		}

		deque.clear();
		assertEquals(getNextPowerOfTwo(40), getInternalCapacity(deque));
		array = deque.toArray(new Object[0]);
		assertSame(0, array.length);
		array = deque.toArray(new Object[41]);
		assertSame(41, array.length);
		for (Object o : array) {
			assertNull(o);
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#peek()} with random elements.
	 */
	@Test
	public void testPeek() {
		Deque<Object> deque = new CircularArrayDeque<Object>();

		assertNull(deque.peek());

		deque.offer(null);
		assertSame(null, deque.peek());
		List<Object> lastAdded = new ArrayList<Object>();
		for (int i = 0; i < 20; i++) {
			String rand = getRandomString();
			while (deque.contains(rand)) {
				rand = getRandomString();
			}
			deque.offer(rand);
			assertSame(null, deque.peek());
		}
		for (int i = 0; i < 20; i++) {
			String rand = getRandomString();
			while (deque.contains(rand)) {
				rand = getRandomString();
			}
			deque.addFirst(rand);
			lastAdded.add(rand);
			assertEquals(rand, deque.peek());
		}
		for (int i = 0; i < 20; i++) {
			assertEquals(lastAdded.get(lastAdded.size() - i - 1), deque.peek());
			deque.removeFirst();
		}
		assertSame(null, deque.peek());

		deque.addAll(lastAdded);
		deque.clear();

		assertNull(deque.peek());
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#peekFirst()} with random elements.
	 */
	@Test
	public void testPeekFirst() {
		Deque<Object> deque = new CircularArrayDeque<Object>();

		try {
			deque.peekFirst();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$
		} catch (NoSuchElementException e) {
			// expected
		}

		deque.offer(null);
		assertSame(null, deque.peekFirst());
		for (int i = 0; i < 20; i++) {
			String rand = getRandomString();
			while (deque.contains(rand)) {
				rand = getRandomString();
			}
			deque.offer(rand);
			assertSame(null, deque.peekFirst());
		}
		List<Object> lastAdded = new ArrayList<Object>();
		for (int i = 0; i < 20; i++) {
			String rand = getRandomString();
			while (deque.contains(rand)) {
				rand = getRandomString();
			}
			deque.addFirst(rand);
			lastAdded.add(rand);
			assertEquals(rand, deque.peekFirst());
		}
		for (int i = 0; i < 20; i++) {
			deque.removeFirst();
			if (i < 19) {
				assertEquals(lastAdded.get(lastAdded.size() - i - 2), deque.peekFirst());
			} else {
				assertSame(null, deque.peekFirst());
			}
		}

		deque.clear();
		try {
			deque.peekFirst();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$
		} catch (NoSuchElementException e) {
			// expected
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#peekLast()} with random elements.
	 */
	@Test
	public void testPeekLast() {
		Deque<Object> deque = new CircularArrayDeque<Object>();

		try {
			deque.peekLast();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$
		} catch (NoSuchElementException e) {
			// expected
		}

		deque.offer(null);
		assertSame(null, deque.peekLast());
		List<Object> lastAdded = new ArrayList<Object>();
		for (int i = 0; i < 20; i++) {
			String rand = getRandomString();
			while (deque.contains(rand)) {
				rand = getRandomString();
			}
			deque.offer(rand);
			lastAdded.add(rand);
			assertEquals(rand, deque.peekLast());
		}
		for (int i = 0; i < 20; i++) {
			String rand = getRandomString();
			while (deque.contains(rand)) {
				rand = getRandomString();
			}
			deque.addFirst(rand);
			assertEquals(lastAdded.get(lastAdded.size() - 1), deque.peekLast());
		}
		for (int i = 0; i < 20; i++) {
			deque.removeLast();
			if (i < 19) {
				assertEquals(lastAdded.get(lastAdded.size() - i - 2), deque.peekLast());
			} else {
				assertSame(null, deque.peekLast());
			}
		}

		deque.clear();
		try {
			deque.peekLast();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$
		} catch (NoSuchElementException e) {
			// expected
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#poll()} with random elements.
	 */
	@Test
	public void testPoll() {
		Deque<Object> deque = new CircularArrayDeque<Object>();
		List<String> objectsFirst = randomStringListNotIn(20, Collections.emptySet());
		List<String> objectsLast = randomStringListNotIn(20, objectsFirst);

		assertFalse(deque.containsAll(objectsFirst));
		assertFalse(deque.containsAll(objectsLast));

		assertNull(deque.poll());

		for (Object o : objectsLast) {
			deque.offer(o);
		}
		for (Object o : objectsFirst) {
			deque.addFirst(o);
		}
		assertTrue(deque.containsAll(objectsFirst));
		assertTrue(deque.containsAll(objectsLast));

		for (int i = objectsFirst.size() - 1; i >= 0; i--) {
			assertEquals(objectsFirst.get(i), deque.poll());
		}
		for (Object o : objectsLast) {
			assertEquals(o, deque.poll());
		}

		assertNull(deque.poll());

		deque.addAll(objectsFirst);
		deque.addAll(objectsLast);
		deque.clear();

		assertNull(deque.poll());
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#pop()} with random elements.
	 */
	@Test
	public void testPop() {
		Deque<Object> deque = new CircularArrayDeque<Object>();
		List<String> objectsFirst = randomStringListNotIn(20, Collections.emptySet());
		List<String> objectsLast = randomStringListNotIn(20, objectsFirst);

		assertFalse(deque.containsAll(objectsFirst));
		assertFalse(deque.containsAll(objectsLast));

		try {
			deque.pop();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$			
		} catch (NoSuchElementException e) {
			// expected
		}

		for (Object o : objectsLast) {
			deque.offer(o);
		}
		for (Object o : objectsFirst) {
			deque.addFirst(o);
		}
		assertTrue(deque.containsAll(objectsFirst));
		assertTrue(deque.containsAll(objectsLast));

		for (int i = objectsLast.size() - 1; i >= 0; i--) {
			assertEquals(objectsLast.get(i), deque.pop());
		}
		for (Object o : objectsFirst) {
			assertEquals(o, deque.pop());
		}

		try {
			deque.pop();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$			
		} catch (NoSuchElementException e) {
			// expected
		}

		deque.addAll(objectsFirst);
		deque.addAll(objectsLast);
		deque.clear();
		try {
			deque.pop();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$			
		} catch (NoSuchElementException e) {
			// expected
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#remove(Object)} with random elements.
	 */
	@Test
	public void testRemove() {
		Deque<Object> deque = new CircularArrayDeque<Object>();
		List<String> objects = randomStringListNotIn(20, Collections.emptySet());

		assertFalse(deque.containsAll(objects));

		for (Object o : objects) {
			boolean removed = deque.remove(o);
			assertFalse(removed);
			assertFalse(deque.contains(o));
		}

		for (Object o : objects) {
			deque.offer(o);
		}
		assertTrue(deque.containsAll(objects));

		for (Object o : objects) {
			assertTrue(deque.contains(o));
			boolean removed = deque.remove(o);
			assertTrue(removed);
			assertFalse(deque.contains(o));
		}

		assertFalse(deque.containsAll(objects));

		for (Object o : objects) {
			boolean removed = deque.remove(o);
			assertFalse(removed);
			assertFalse(deque.contains(o));
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#removeAll(Collection)} with random elements.
	 */
	@Test
	public void testRemoveAll() {
		Collection<Object> emptyCollection = Collections.emptyList();
		Collection<Integer> listInt10 = randomIntegerListNotIn(10, Collections.emptySet());
		Collection<String> setString20 = randomStringSetNotIn(20, Collections.emptySet());
		Collection<String> dequeString40 = randomStringDequeNotIn(40, setString20);

		Deque<Object> deque = new CircularArrayDeque<Object>();

		deque.addAll(listInt10);
		deque.addAll(emptyCollection);
		deque.addAll(setString20);
		deque.addAll(dequeString40);
		assertEquals(listInt10.size() + setString20.size() + dequeString40.size(), deque.size());
		assertTrue(deque.containsAll(listInt10));
		assertTrue(deque.containsAll(setString20));
		assertTrue(deque.containsAll(dequeString40));
		int expectedCapacity = getNextPowerOfTwo(deque.size());
		assertEquals(expectedCapacity, getInternalCapacity(deque));

		boolean modified = deque.removeAll(listInt10);
		assertTrue(modified);
		assertEquals(setString20.size() + dequeString40.size(), deque.size());
		assertFalse(deque.containsAll(listInt10));
		assertTrue(deque.containsAll(setString20));
		assertTrue(deque.containsAll(dequeString40));
		assertEquals(expectedCapacity, getInternalCapacity(deque));

		modified = deque.removeAll(emptyCollection);
		assertFalse(modified);
		assertEquals(setString20.size() + dequeString40.size(), deque.size());
		assertFalse(deque.containsAll(listInt10));
		assertTrue(deque.containsAll(setString20));
		assertTrue(deque.containsAll(dequeString40));
		assertEquals(expectedCapacity, getInternalCapacity(deque));

		deque.addAll(listInt10);
		assertEquals(listInt10.size() + setString20.size() + dequeString40.size(), deque.size());
		assertTrue(deque.containsAll(listInt10));
		assertTrue(deque.containsAll(setString20));
		assertTrue(deque.containsAll(dequeString40));
		assertEquals(expectedCapacity, getInternalCapacity(deque));

		modified = deque.removeAll(setString20);
		assertTrue(modified);
		assertEquals(listInt10.size() + dequeString40.size(), deque.size());
		assertTrue(deque.containsAll(listInt10));
		assertFalse(deque.containsAll(setString20));
		assertTrue(deque.containsAll(dequeString40));
		assertEquals(expectedCapacity, getInternalCapacity(deque));

		modified = deque.removeAll(dequeString40);
		assertTrue(modified);
		assertEquals(listInt10.size(), deque.size());
		assertTrue(deque.containsAll(listInt10));
		assertFalse(deque.containsAll(setString20));
		assertFalse(deque.containsAll(dequeString40));
		assertEquals(expectedCapacity, getInternalCapacity(deque));

		modified = deque.removeAll(listInt10);
		assertTrue(modified);
		assertEquals(0, deque.size());
		assertFalse(deque.containsAll(listInt10));
		assertFalse(deque.containsAll(setString20));
		assertFalse(deque.containsAll(dequeString40));
		assertEquals(expectedCapacity, getInternalCapacity(deque));

		assertTrue(deque.isEmpty());

		modified = deque.removeAll(listInt10);
		assertFalse(modified);
		modified = deque.removeAll(setString20);
		assertFalse(modified);
		modified = deque.removeAll(dequeString40);
		assertFalse(modified);

		deque.add(null);
		assertTrue(deque.contains(null));
		assertFalse(deque.isEmpty());
		deque.removeAll(Collections.singleton(null));
		assertFalse(deque.contains(null));
		assertTrue(deque.isEmpty());
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#removeAll(Collection)} with random elements.
	 */
	@Test
	public void testRemoveAllBothRotate() {
		Object[] testObjects = new Object[] {"abcd", "", "*", "?", "\n", '\'', null, 4, 4.3, 5L, 4.3d, //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
				new Object() };

		for (int i = 0; i < testObjects.length; i++) {
			List<Object> testCollection = new ArrayList<Object>();
			testCollection.add(testObjects[i]);
			testCollection.add(testObjects[testObjects.length - 1 - i]);
			internalTestRemoveAllBothRotate(testCollection);
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#removeAll(Collection)} with random elements.
	 */
	@Test
	public void testRemoveAllLeftRotate() {
		Object[] testObjects = new Object[] {"abcd", "", "*", "?", "\n", '\'', null, 4, 4.3, 5L, 4.3d, //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
				new Object() };

		for (int i = 0; i < testObjects.length; i++) {
			List<Object> testCollection = new ArrayList<Object>();
			testCollection.add(testObjects[i]);
			testCollection.add(testObjects[testObjects.length - 1 - i]);
			internalTestRemoveAllLeftRotate(testCollection);
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#removeAll(Collection)} with random elements.
	 */
	@Test
	public void testRemoveAllRightRotate() {
		Object[] testObjects = new Object[] {"abcd", "", "*", "?", "\n", '\'', null, 4, 4.3, 5L, 4.3d, //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
				new Object() };

		for (int i = 0; i < testObjects.length; i++) {
			List<Object> testCollection = new ArrayList<Object>();
			testCollection.add(testObjects[i]);
			testCollection.add(testObjects[testObjects.length - 1 - i]);
			internalTestRemoveAllRightRotate(testCollection);
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#removeFirst()} with random elements.
	 */
	@Test
	public void testRemoveFirst() {
		Deque<Object> deque = new CircularArrayDeque<Object>();
		List<String> objectsFirst = randomStringListNotIn(20, Collections.emptySet());
		List<String> objectsLast = randomStringListNotIn(20, objectsFirst);

		assertFalse(deque.containsAll(objectsFirst));
		assertFalse(deque.containsAll(objectsLast));

		try {
			deque.removeFirst();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$			
		} catch (NoSuchElementException e) {
			// expected
		}

		for (Object o : objectsLast) {
			deque.offer(o);
		}
		for (Object o : objectsFirst) {
			deque.addFirst(o);
		}
		assertTrue(deque.containsAll(objectsFirst));
		assertTrue(deque.containsAll(objectsLast));

		for (int i = objectsFirst.size() - 1; i >= 0; i--) {
			assertEquals(objectsFirst.get(i), deque.removeFirst());
		}
		for (Object o : objectsLast) {
			assertEquals(o, deque.removeFirst());
		}

		try {
			deque.removeFirst();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$			
		} catch (NoSuchElementException e) {
			// expected
		}

		deque.addAll(objectsFirst);
		deque.addAll(objectsLast);
		deque.clear();
		try {
			deque.removeFirst();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$			
		} catch (NoSuchElementException e) {
			// expected
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#removeLast()} with random elements.
	 */
	@Test
	public void testRemoveLast() {
		Deque<Object> deque = new CircularArrayDeque<Object>();
		List<String> objectsFirst = randomStringListNotIn(20, Collections.emptySet());
		List<String> objectsLast = randomStringListNotIn(20, objectsFirst);

		assertFalse(deque.containsAll(objectsFirst));
		assertFalse(deque.containsAll(objectsLast));

		try {
			deque.removeLast();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$			
		} catch (NoSuchElementException e) {
			// expected
		}

		for (Object o : objectsLast) {
			deque.offer(o);
		}
		for (Object o : objectsFirst) {
			deque.addFirst(o);
		}
		assertTrue(deque.containsAll(objectsFirst));
		assertTrue(deque.containsAll(objectsLast));

		for (int i = objectsLast.size() - 1; i >= 0; i--) {
			assertEquals(objectsLast.get(i), deque.removeLast());
		}
		for (Object o : objectsFirst) {
			assertEquals(o, deque.removeLast());
		}

		try {
			deque.removeLast();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$			
		} catch (NoSuchElementException e) {
			// expected
		}

		deque.addAll(objectsFirst);
		deque.addAll(objectsLast);
		deque.clear();
		try {
			deque.removeLast();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$			
		} catch (NoSuchElementException e) {
			// expected
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#remove(Object)} with random elements.
	 */
	@Test
	public void testRemoveLeftRotate() {
		Object[] testObjects = new Object[] {"abcd", "", "*", "?", "\n", '\'', null, 4, 4.3, 5L, 4.3d, //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
				new Object() };
		for (int i = 0; i < testObjects.length; i++) {
			internalTestRemoveLeftRotate(testObjects[i]);
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#remove()} with random elements.
	 */
	@Test
	public void testRemoveQueue() {
		Deque<Object> deque = new CircularArrayDeque<Object>();
		List<String> objectsFirst = randomStringListNotIn(20, Collections.emptySet());
		List<String> objectsLast = randomStringListNotIn(20, objectsFirst);

		assertFalse(deque.containsAll(objectsFirst));
		assertFalse(deque.containsAll(objectsLast));

		try {
			deque.remove();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$			
		} catch (NoSuchElementException e) {
			// expected
		}

		for (Object o : objectsLast) {
			deque.offer(o);
		}
		for (Object o : objectsFirst) {
			deque.addFirst(o);
		}
		assertTrue(deque.containsAll(objectsFirst));
		assertTrue(deque.containsAll(objectsLast));

		for (int i = objectsFirst.size() - 1; i >= 0; i--) {
			assertEquals(objectsFirst.get(i), deque.remove());
		}
		for (Object o : objectsLast) {
			assertEquals(o, deque.remove());
		}

		try {
			deque.remove();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$			
		} catch (NoSuchElementException e) {
			// expected
		}

		deque.addAll(objectsFirst);
		deque.addAll(objectsLast);
		deque.clear();
		try {
			deque.remove();
			fail("Expected NoSuchElementException hasn't been thrown"); //$NON-NLS-1$			
		} catch (NoSuchElementException e) {
			// expected
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#remove(Object)} with random elements.
	 */
	@Test
	public void testRemoveRightRotate() {
		Object[] testObjects = new Object[] {"abcd", "", "*", "?", "\n", '\'', null, 4, 4.3, 5L, 4.3d, //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
				new Object() };
		for (int i = 0; i < testObjects.length; i++) {
			internalTestRemoveRightRotate(testObjects[i]);
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#retainAll(Collection)} with random elements.
	 */
	@Test
	public void testRetainAll() {
		Collection<Object> emptyCollection = Collections.emptyList();
		Collection<Integer> listInt10 = randomIntegerListNotIn(10, Collections.emptySet());
		Collection<String> setString20 = randomStringSetNotIn(20, Collections.emptySet());
		Collection<String> dequeString40 = randomStringDequeNotIn(40, setString20);

		Deque<Object> deque = new CircularArrayDeque<Object>();
		deque.addAll(listInt10);
		deque.addAll(emptyCollection);
		deque.addAll(setString20);
		deque.addAll(dequeString40);

		boolean modified = deque.retainAll(dequeString40);
		assertTrue(modified);
		assertSame(dequeString40.size(), deque.size());
		for (Integer integer : listInt10) {
			assertFalse(deque.contains(integer));
		}
		for (String string : setString20) {
			assertFalse(deque.contains(string));
		}
		for (String string : dequeString40) {
			assertTrue(deque.contains(string));
		}

		deque = new CircularArrayDeque<Object>();
		deque.addAll(listInt10);
		deque.addAll(emptyCollection);
		deque.addAll(setString20);
		deque.addAll(dequeString40);

		modified = deque.retainAll(setString20);
		assertTrue(modified);
		assertSame(setString20.size(), deque.size());
		for (Integer integer : listInt10) {
			assertFalse(deque.contains(integer));
		}
		for (String string : setString20) {
			assertTrue(deque.contains(string));
		}
		for (String string : dequeString40) {
			assertFalse(deque.contains(string));
		}

		deque = new CircularArrayDeque<Object>();
		deque.addAll(listInt10);
		deque.addAll(emptyCollection);
		deque.addAll(setString20);
		deque.addAll(dequeString40);

		modified = deque.retainAll(listInt10);
		assertTrue(modified);
		assertSame(listInt10.size(), deque.size());
		for (Integer integer : listInt10) {
			assertTrue(deque.contains(integer));
		}
		for (String string : setString20) {
			assertFalse(deque.contains(string));
		}
		for (String string : dequeString40) {
			assertFalse(deque.contains(string));
		}

		deque = new CircularArrayDeque<Object>();
		deque.addAll(listInt10);
		deque.addAll(emptyCollection);
		deque.addAll(setString20);
		deque.addAll(dequeString40);

		modified = deque.retainAll(emptyCollection);
		assertTrue(modified);
		assertSame(0, deque.size());
		for (Integer integer : listInt10) {
			assertFalse(deque.contains(integer));
		}
		for (String string : setString20) {
			assertFalse(deque.contains(string));
		}
		for (String string : dequeString40) {
			assertFalse(deque.contains(string));
		}

		deque = new CircularArrayDeque<Object>();
		modified = deque.retainAll(emptyCollection);
		assertFalse(modified);
		assertSame(0, deque.size());

		modified = deque.retainAll(listInt10);
		assertFalse(modified);
		assertSame(0, deque.size());

		modified = deque.retainAll(dequeString40);
		assertFalse(modified);
		assertSame(0, deque.size());
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#set(int, Object)} with random elements.
	 */
	@Test
	public void testSet() {
		Integer integer1 = -1;
		Integer integer2 = -2;
		String string1 = "a";
		String string2 = "b";
		Object object1 = new Object();
		Object object2 = new Object();

		Deque<Object> deque = new CircularArrayDeque<Object>();

		int[] invalidIndices = new int[] {0, -1, Integer.MIN_VALUE, deque.size() + 1 };
		for (int i : invalidIndices) {
			try {
				deque.set(i, string2);
				fail("Expected IndexOutOfBoundsException hasn't been thrown"); //$NON-NLS-1$
			} catch (IndexOutOfBoundsException e) {
				// expected
			}
		}

		deque.add(integer1);
		deque.add(string1);
		deque.add(object1);

		invalidIndices = new int[] {-1, Integer.MIN_VALUE, deque.size() + 1 };
		for (int i : invalidIndices) {
			try {
				deque.set(i, string2);
				fail("Expected IndexOutOfBoundsException hasn't been thrown"); //$NON-NLS-1$
			} catch (IndexOutOfBoundsException e) {
				// expected
			}
		}

		assertEquals(integer1, deque.set(0, integer2));
		assertEquals(integer2, deque.get(0));
		assertFalse(deque.contains(integer1));
		assertSame(3, deque.size());

		assertEquals(string1, deque.set(1, string2));
		assertEquals(string2, deque.get(1));
		assertFalse(deque.contains(string1));
		assertSame(3, deque.size());

		assertEquals(object1, deque.set(2, object2));
		assertEquals(object2, deque.get(2));
		assertFalse(deque.contains(object1));
		assertSame(3, deque.size());

		assertEquals(string2, deque.set(1, integer2));
		assertEquals(integer2, deque.get(1));
		assertFalse(deque.contains(string2));
		assertSame(3, deque.size());

		assertEquals(object2, deque.set(2, integer2));
		assertEquals(integer2, deque.get(2));
		assertFalse(deque.contains(object2));
		assertSame(3, deque.size());

		invalidIndices = new int[] {-1, Integer.MIN_VALUE, deque.size() + 1 };
		for (int i : invalidIndices) {
			try {
				deque.set(i, string2);
				fail("Expected IndexOutOfBoundsException hasn't been thrown"); //$NON-NLS-1$
			} catch (IndexOutOfBoundsException e) {
				// expected
			}
		}

		deque.clear();

		invalidIndices = new int[] {0, -1, Integer.MIN_VALUE, deque.size() + 1 };
		for (int i : invalidIndices) {
			try {
				deque.set(i, string2);
				fail("Expected IndexOutOfBoundsException hasn't been thrown"); //$NON-NLS-1$
			} catch (IndexOutOfBoundsException e) {
				// expected
			}
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#size()} with random elements.
	 */
	@Test
	public void testSize() {
		Deque<Object> deque = new CircularArrayDeque<Object>();

		int size = 0;
		assertSame(size, deque.size());

		deque.offer(null);
		assertSame(++size, deque.size());

		for (int i = 0; i < 100; i++) {
			String rand = getRandomString();
			while (deque.contains(rand)) {
				rand = getRandomString();
			}
			deque.offer(rand);
			assertSame(++size, deque.size());
		}

		for (int i = 0; i < 100; i++) {
			deque.pop();
			assertSame(--size, deque.size());
		}
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#subList(int, int)} with random elements. As this is
	 * fully inherited from AbstractList, we'll only test that the operation is accessible.
	 */
	@Test
	public void testSubList() {
		Collection<Integer> listInt10 = randomIntegerListNotIn(10, Collections.emptySet());
		Collection<String> setString20 = randomStringSetNotIn(20, Collections.emptySet());

		Deque<Object> deque = new CircularArrayDeque<Object>();

		List<Object> subList = deque.subList(0, 0);
		assertEquals(subList, deque);
		assertTrue(subList.isEmpty());

		try {
			deque.subList(0, 5);
			fail("Expected IndexOutOfBoundsException hasn't been thrown"); //$NON-NLS-1$
		} catch (IndexOutOfBoundsException e) {
			// Expected
		}

		deque.addAll(listInt10);
		deque.addAll(setString20);

		subList = deque.subList(0, deque.size());
		assertEquals(subList, deque);

		subList = deque.subList(0, listInt10.size());
		assertSame(listInt10.size(), subList.size());
		assertTrue(subList.containsAll(listInt10));

		subList = deque.subList(0, listInt10.size() + setString20.size());
		assertSame(listInt10.size() + setString20.size(), subList.size());
		assertTrue(subList.containsAll(listInt10));
		assertTrue(subList.containsAll(setString20));

		try {
			deque.subList(-1, 10);
			fail("Expected IndexOutOfBoundsException hasn't been thrown"); //$NON-NLS-1$
		} catch (IndexOutOfBoundsException e) {
			// Expected
		}

		try {
			deque.subList(5, 0);
			fail("Expected IllegalArgumentException hasn't been thrown"); //$NON-NLS-1$
		} catch (IllegalArgumentException e) {
			// Expected
		}

		subList = deque.subList(5, 5);
		assertSame(0, subList.size());
		assertTrue(subList.isEmpty());
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#toArray()} with random elements.
	 */
	@Test
	public void testToArray() {
		Deque<Object> deque = new CircularArrayDeque<Object>();
		List<String> objectsFirst = randomStringListNotIn(20, Collections.emptySet());
		List<String> objectsLast = randomStringListNotIn(20, objectsFirst);

		Object[] array = deque.toArray();
		assertSame(0, array.length);

		deque.addAll(objectsLast);
		array = deque.toArray();
		assertSame(deque.size(), array.length);
		Iterator<Object> dequeIterator = deque.iterator();
		for (int i = 0; i < array.length; i++) {
			assertEquals(dequeIterator.next(), array[i]);
		}
		deque.clear();

		deque.addAll(objectsLast);
		for (Object o : objectsFirst) {
			deque.addFirst(o);
		}
		array = deque.toArray();
		assertSame(deque.size(), array.length);
		dequeIterator = deque.iterator();
		for (int i = 0; i < array.length; i++) {
			assertEquals(dequeIterator.next(), array[i]);
		}

		deque.clear();
		array = deque.toArray();
		assertEquals(getNextPowerOfTwo(40), getInternalCapacity(deque));
		assertSame(0, array.length);
	}

	/**
	 * Checks that the two arrays contain the same content.
	 * 
	 * @param expected
	 *            First of the two array to compare.
	 * @param actual
	 *            Second of the two array to compare.
	 */
	private void assertEqualContent(Object[] expected, Object[] actual) {
		assertEquals(expected.length, actual.length);
		for (int i = 0; i < expected.length; i++) {
			if (expected[i] == null) {
				assertSame(expected[i], actual[i]);
			} else {
				assertEquals(expected[i], actual[i]);
			}
		}
	}

	/**
	 * Makes the "data" field of the given deque public in order to retrieve it.
	 * 
	 * @param deque
	 *            The deque we need the internal array of.
	 * @return The internal array of the given deque.
	 */
	private Object[] getInternalArray(Deque<?> deque) {
		Field dataField = null;
		for (Field field : deque.getClass().getDeclaredFields()) {
			if (field.getName().equals("data")) { //$NON-NLS-1$
				dataField = field;
				break;
			}
		}
		assertNotNull(dataField);
		assert dataField != null;
		dataField.setAccessible(true);
		Object[] data = null;
		try {
			data = (Object[])dataField.get(deque);
		} catch (IllegalArgumentException e) {
			// carry on
		} catch (IllegalAccessException e) {
			// carry on
		}
		if (data == null) {
			fail("could not retrieve capacity of " + deque); //$NON-NLS-1$
		}
		return data;
	}

	/**
	 * Makes the "data" field of the given deque public in order to retrieve its current size.
	 * 
	 * @param deque
	 *            The deque we need the capacity of.
	 * @return The capacity of the given deque.
	 */
	private int getInternalCapacity(Deque<?> deque) {
		Object[] data = getInternalArray(deque);
		return data.length;
	}

	/**
	 * Get the closest power of two greater than <code>number</code>.
	 * 
	 * @param number
	 *            Number for which we seek the closest power of two.
	 * @return The closest power of two greater than <code>number</code>.
	 */
	private int getNextPowerOfTwo(int number) {
		int powerOfTwo = number--;
		powerOfTwo |= powerOfTwo >> 1;
		powerOfTwo |= powerOfTwo >> 2;
		powerOfTwo |= powerOfTwo >> 4;
		powerOfTwo |= powerOfTwo >> 8;
		powerOfTwo |= powerOfTwo >> 16;
		powerOfTwo++;
		return powerOfTwo;
	}

	/**
	 * Returns a random Integer between 0 and 10000000.
	 * 
	 * @return A random Integer between 0 and 10000000.
	 */
	private Integer getRandomInteger() {
		return Integer.valueOf(Double.valueOf(Math.random() * 10000000d).intValue());
	}

	/**
	 * Returns a random String representing an integer between 0 and 10000000.
	 * 
	 * @return A random String representing an integer between 0 and 10000000.
	 */
	private String getRandomString() {
		return getRandomInteger().toString();
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#addAll(int, Collection)} with the given Collection. For
	 * the sake of this test, all collections will have a size of 2.
	 * 
	 * @param collection
	 *            Collection to insert into the deque.
	 */
	private void internalTestAddAllRandomAccessLeftRotate(List<Object> collection) {
		// //////////////////////////////////////////
		// Array : _ _ _ _ _ _ _ _ a a a a a a _ _ //
		// expect: _ _ _ _ _ _ a a ? ? a a a a _ _ //
		// //////////////////////////////////////////
		Deque<Object> deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 14; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 8; i++) {
			deque.removeFirst();
		}

		deque.addAll(2, collection);
		Object[] data = getInternalArray(deque);
		Object[] expected = new Object[] {null, null, null, null, null, null, "a", "a", collection.get(0),
				collection.get(1), "a", "a", "a", "a", null, null };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : _ a a a a a a _ _ _ _ _ _ _ _ _ //
		// expect: a ? ? a a a a _ _ _ _ _ _ _ _ a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 7; i++) {
			deque.offer("a");
		}
		deque.removeFirst();

		deque.addAll(2, collection);
		data = getInternalArray(deque);
		expected = new Object[] {"a", collection.get(0), collection.get(1), "a", "a", "a", "a", null, null,
				null, null, null, null, null, null, "a" };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a a a a a a a _ _ _ _ _ _ _ _ _ //
		// expect: a ? ? a a a a _ _ _ _ _ _ _ a a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 7; i++) {
			deque.offer("a");
		}

		deque.addAll(3, collection);
		data = getInternalArray(deque);
		expected = new Object[] {"a", collection.get(0), collection.get(1), "a", "a", "a", "a", null, null,
				null, null, null, null, null, "a", "a" };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a a a a a a _ _ _ _ _ _ _ _ _ a //
		// expect: ? ? a a a a _ _ _ _ _ _ _ a a a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 14; i++) {
			deque.removeFirst();
		}
		for (int i = 0; i < 7; i++) {
			deque.offer("a");
		}
		deque.removeFirst();

		deque.addAll(3, collection);
		data = getInternalArray(deque);
		expected = new Object[] {collection.get(0), collection.get(1), "a", "a", "a", "a", null, null, null,
				null, null, null, null, "a", "a", "a" };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a a a a a _ _ _ _ _ _ _ _ _ a a //
		// expect: ? a a a a _ _ _ _ _ _ _ a a a ? //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 14; i++) {
			deque.removeFirst();
		}
		for (int i = 0; i < 6; i++) {
			deque.offer("a");
		}

		deque.addAll(3, collection);
		data = getInternalArray(deque);
		expected = new Object[] {collection.get(1), "a", "a", "a", "a", null, null, null, null, null, null,
				null, "a", "a", "a", collection.get(0) };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a a a a _ _ _ _ _ _ _ _ _ a a a //
		// expect: a a a a _ _ _ _ _ _ _ a a a ? ? //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 13; i++) {
			deque.removeFirst();
		}
		for (int i = 0; i < 5; i++) {
			deque.offer("a");
		}

		deque.addAll(3, collection);
		data = getInternalArray(deque);
		expected = new Object[] {"a", "a", "a", "a", null, null, null, null, null, null, null, "a", "a", "a",
				collection.get(0), collection.get(1) };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////////////////////////////////////
		// Array : a a a a a a a _ a a a a a a a a //
		// expect: a a ? ? a a a a a a a a a a a _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ a a //
		// //////////////////////////////////////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 8; i++) {
			deque.removeFirst();
		}
		for (int i = 0; i < 8; i++) {
			deque.offer("a");
		}

		deque.addAll(4, collection);
		data = getInternalArray(deque);
		expected = new Object[32];
		for (int i = 0; i < 2; i++) {
			expected[i] = "a";
		}
		expected[2] = collection.get(0);
		expected[3] = collection.get(1);
		for (int i = 4; i < 15; i++) {
			expected[i] = "a";
		}
		expected[30] = "a";
		expected[31] = "a";
		assertEqualContent(expected, data);
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#addAll(int, Collection)} with the given Collection. For
	 * the sake of this test, all collections will have a size of 2.
	 * 
	 * @param collection
	 *            Collection to insert into the deque.
	 */
	private void internalTestAddAllRandomAccessRightRotate(List<Object> collection) {
		// //////////////////////////////////////////
		// Array : _ _ _ _ _ _ _ _ a a a a a a _ _ //
		// expect: _ _ _ _ _ _ _ _ a a a a ? ? a a //
		// //////////////////////////////////////////
		Deque<Object> deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 14; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 8; i++) {
			deque.removeFirst();
		}

		deque.addAll(4, collection);
		Object[] data = getInternalArray(deque);
		Object[] expected = new Object[] {null, null, null, null, null, null, null, null, "a", "a", "a", "a",
				collection.get(0), collection.get(1), "a", "a" };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : _ _ _ _ _ _ _ _ _ a a a a a a _ //
		// expect: a _ _ _ _ _ _ _ _ a a a a ? ? a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 9; i++) {
			deque.removeFirst();
		}

		deque.addAll(4, collection);
		data = getInternalArray(deque);
		expected = new Object[] {"a", null, null, null, null, null, null, null, null, "a", "a", "a", "a",
				collection.get(0), collection.get(1), "a" };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : _ _ _ _ _ _ _ _ _ a a a a a a a //
		// expect: a a _ _ _ _ _ _ _ a a a a ? ? a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 9; i++) {
			deque.removeFirst();
		}
		deque.offer("a");

		deque.addAll(4, collection);
		data = getInternalArray(deque);
		expected = new Object[] {"a", "a", null, null, null, null, null, null, null, "a", "a", "a", "a",
				collection.get(0), collection.get(1), "a" };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a _ _ _ _ _ _ _ _ _ a a a a a a //
		// expect: a a a _ _ _ _ _ _ _ a a a a ? ? //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 10; i++) {
			deque.removeFirst();
		}
		deque.offer("a");
		deque.offer("a");

		deque.addAll(4, collection);
		data = getInternalArray(deque);
		expected = new Object[] {"a", "a", "a", null, null, null, null, null, null, null, "a", "a", "a", "a",
				collection.get(0), collection.get(1) };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a a _ _ _ _ _ _ _ _ _ a a a a a //
		// expect: ? a a a _ _ _ _ _ _ _ a a a a ? //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 11; i++) {
			deque.removeFirst();
		}
		deque.offer("a");
		deque.offer("a");
		deque.offer("a");

		deque.addAll(4, collection);
		data = getInternalArray(deque);
		expected = new Object[] {collection.get(1), "a", "a", "a", null, null, null, null, null, null, null,
				"a", "a", "a", "a", collection.get(0) };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a a _ _ _ _ _ _ _ _ _ _ a a a a //
		// expect: ? ? a a _ _ _ _ _ _ _ _ a a a a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 12; i++) {
			deque.removeFirst();
		}
		deque.offer("a");
		deque.offer("a");
		deque.offer("a");

		deque.addAll(4, collection);
		data = getInternalArray(deque);
		expected = new Object[] {collection.get(0), collection.get(1), "a", "a", null, null, null, null,
				null, null, null, null, "a", "a", "a", "a" };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////////////////////////////////////
		// Array : a a a a a a a _ a a a a a a a a //
		// expect: a a a a a a a a a a a ? ? a a a a _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ //
		// //////////////////////////////////////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 7; i++) {
			deque.removeFirst();
		}
		for (int i = 0; i < 7; i++) {
			deque.offer("a");
		}

		deque.addAll(11, collection);
		data = getInternalArray(deque);
		expected = new Object[32];
		for (int i = 0; i < 11; i++) {
			expected[i] = "a";
		}
		expected[11] = collection.get(0);
		expected[12] = collection.get(1);
		for (int i = 13; i < 17; i++) {
			expected[i] = "a";
		}
		assertEqualContent(expected, data);
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#add(int, Object)} with the given element.
	 * 
	 * @param element
	 *            Element to insert into the deque.
	 */
	private void internalTestAddRandomAccessLeftRotate(Object element) {
		// //////////////////////////////////////////
		// Array : _ _ _ _ _ _ _ _ a a a a a a a _ //
		// expect: _ _ _ _ _ _ _ a a a ? a a a a _ //
		// //////////////////////////////////////////
		Deque<Object> deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 8; i++) {
			deque.removeFirst();
		}

		deque.add(3, element);
		Object[] data = getInternalArray(deque);
		Object[] expected = new Object[] {null, null, null, null, null, null, null, "a", "a", "a", element,
				"a", "a", "a", "a", null };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a a a a a a a _ _ _ _ _ _ _ _ _ //
		// expect: a a ? a a a a _ _ _ _ _ _ _ _ a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 7; i++) {
			deque.offer("a");
		}

		deque.add(3, element);
		data = getInternalArray(deque);
		expected = new Object[] {"a", "a", element, "a", "a", "a", "a", null, null, null, null, null, null,
				null, null, "a" };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a a a a a _ _ _ _ _ _ _ _ _ a a //
		// expect: ? a a a a _ _ _ _ _ _ _ _ a a a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 14; i++) {
			deque.removeFirst();
		}
		for (int i = 0; i < 6; i++) {
			deque.offer("a");
		}

		deque.add(3, element);
		data = getInternalArray(deque);
		expected = new Object[] {element, "a", "a", "a", "a", null, null, null, null, null, null, null, null,
				"a", "a", "a" };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a a a a _ _ _ _ _ _ _ _ _ a a a //
		// expect: a a a a _ _ _ _ _ _ _ _ a a a ? //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 13; i++) {
			deque.removeFirst();
		}
		for (int i = 0; i < 5; i++) {
			deque.offer("a");
		}

		deque.add(3, element);
		data = getInternalArray(deque);
		expected = new Object[] {"a", "a", "a", "a", null, null, null, null, null, null, null, null, "a",
				"a", "a", element };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////////////////////////////////////
		// Array : a a a a a a a _ a a a a a a a a //
		// expect: a a a ? a a a a a a a a a a a a _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ //
		// //////////////////////////////////////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 7; i++) {
			deque.removeFirst();
		}
		for (int i = 0; i < 7; i++) {
			deque.offer("a");
		}

		deque.add(3, element);
		data = getInternalArray(deque);
		expected = new Object[32];
		for (int i = 0; i < 3; i++) {
			expected[i] = "a";
		}
		expected[3] = element;
		for (int i = 4; i < 16; i++) {
			expected[i] = "a";
		}
		assertEqualContent(expected, data);
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#add(int, Object)} with the given element.
	 * 
	 * @param element
	 *            Element to insert into the deque.
	 */
	private void internalTestAddRandomAccessRightRotate(Object element) {
		// //////////////////////////////////////////
		// Array : _ _ _ _ _ _ _ _ a a a a a a a _ //
		// expect: _ _ _ _ _ _ _ _ a a a a ? a a a //
		// //////////////////////////////////////////
		Deque<Object> deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 8; i++) {
			deque.removeFirst();
		}

		deque.add(4, element);
		Object[] data = getInternalArray(deque);
		Object[] expected = new Object[] {null, null, null, null, null, null, null, null, "a", "a", "a", "a",
				element, "a", "a", "a" };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : _ _ _ _ _ _ _ _ _ a a a a a a a //
		// expect: a _ _ _ _ _ _ _ _ a a a a ? a a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 9; i++) {
			deque.removeFirst();
		}
		deque.offer("a");

		deque.add(4, element);
		data = getInternalArray(deque);
		expected = new Object[] {"a", null, null, null, null, null, null, null, null, "a", "a", "a", "a",
				element, "a", "a" };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a a _ _ _ _ _ _ _ _ _ a a a a a //
		// expect: a a a _ _ _ _ _ _ _ _ a a a a ? //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 11; i++) {
			deque.removeFirst();
		}
		deque.offer("a");
		deque.offer("a");
		deque.offer("a");

		deque.add(4, element);
		data = getInternalArray(deque);
		expected = new Object[] {"a", "a", "a", null, null, null, null, null, null, null, null, "a", "a",
				"a", "a", element };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a a a _ _ _ _ _ _ _ _ _ a a a a //
		// expect: ? a a a _ _ _ _ _ _ _ _ a a a a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 12; i++) {
			deque.removeFirst();
		}
		deque.offer("a");
		deque.offer("a");
		deque.offer("a");
		deque.offer("a");

		deque.add(4, element);
		data = getInternalArray(deque);
		expected = new Object[] {element, "a", "a", "a", null, null, null, null, null, null, null, null, "a",
				"a", "a", "a" };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////////////////////////////////////
		// Array : a a a a a a a _ a a a a a a a a //
		// expect: a a a a a a a a a a a ? a a a a _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ //
		// //////////////////////////////////////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 7; i++) {
			deque.removeFirst();
		}
		for (int i = 0; i < 7; i++) {
			deque.offer("a");
		}

		deque.add(11, element);
		data = getInternalArray(deque);
		expected = new Object[32];
		for (int i = 0; i < 11; i++) {
			expected[i] = "a";
		}
		expected[11] = element;
		for (int i = 12; i < 16; i++) {
			expected[i] = "a";
		}
		assertEqualContent(expected, data);
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#removeAll(Collection)} with the given Collection. For
	 * the sake of this test, all collections will have a size of 2.
	 * 
	 * @param collection
	 *            Collection to remove from the deque.
	 */
	private void internalTestRemoveAllBothRotate(List<Object> collection) {
		// //////////////////////////////////////////
		// Array : _ _ _ _ _ a a a ? ? a a a _ _ _ //
		// expect: _ _ _ _ _ _ a a a a a a _ _ _ _ //
		// //////////////////////////////////////////
		Deque<Object> deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 13; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 5; i++) {
			deque.removeFirst();
		}
		deque.set(3, collection.get(0));
		deque.set(4, collection.get(1));

		deque.removeAll(collection);
		Object[] data = getInternalArray(deque);
		Object[] expected = new Object[] {null, null, null, null, null, null, "a", "a", "a", "a", "a", "a",
				null, null, null, null };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : _ _ _ _ _ _ _ _ a a a ? ? a a a //
		// expect: _ _ _ _ _ _ _ _ _ a a a a a a _ //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 8; i++) {
			deque.removeFirst();
		}
		deque.offer("a");
		deque.set(3, collection.get(0));
		deque.set(4, collection.get(1));

		deque.removeAll(collection);
		data = getInternalArray(deque);
		expected = new Object[] {null, null, null, null, null, null, null, null, null, "a", "a", "a", "a",
				"a", "a", null };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a _ _ _ _ _ _ _ _ a a a ? ? a a //
		// expect: _ _ _ _ _ _ _ _ _ _ a a a a a a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 9; i++) {
			deque.removeFirst();
		}
		for (int i = 0; i < 2; i++) {
			deque.offer("a");
		}
		deque.set(3, collection.get(0));
		deque.set(4, collection.get(1));

		deque.removeAll(collection);
		data = getInternalArray(deque);
		expected = new Object[] {null, null, null, null, null, null, null, null, null, null, "a", "a", "a",
				"a", "a", "a" };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a a _ _ _ _ _ _ _ _ a a a ? ? a //
		// expect: a _ _ _ _ _ _ _ _ _ _ a a a a a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 10; i++) {
			deque.removeFirst();
		}
		for (int i = 0; i < 3; i++) {
			deque.offer("a");
		}
		deque.set(3, collection.get(0));
		deque.set(4, collection.get(1));

		deque.removeAll(collection);
		data = getInternalArray(deque);
		expected = new Object[] {"a", null, null, null, null, null, null, null, null, null, null, "a", "a",
				"a", "a", "a" };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a a a _ _ _ _ _ _ _ _ a a a ? ? //
		// expect: a a _ _ _ _ _ _ _ _ _ _ a a a a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 11; i++) {
			deque.removeFirst();
		}
		for (int i = 0; i < 4; i++) {
			deque.offer("a");
		}
		deque.set(3, collection.get(0));
		deque.set(4, collection.get(1));

		deque.removeAll(collection);
		data = getInternalArray(deque);
		expected = new Object[] {"a", "a", null, null, null, null, null, null, null, null, null, null, "a",
				"a", "a", "a" };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : ? a a a _ _ _ _ _ _ _ _ a a a ? //
		// expect: a a a _ _ _ _ _ _ _ _ _ _ a a a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 12; i++) {
			deque.removeFirst();
		}
		for (int i = 0; i < 5; i++) {
			deque.offer("a");
		}
		deque.set(3, collection.get(0));
		deque.set(4, collection.get(1));

		deque.removeAll(collection);
		data = getInternalArray(deque);
		expected = new Object[] {"a", "a", "a", null, null, null, null, null, null, null, null, null, null,
				"a", "a", "a" };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : ? ? a a a _ _ _ _ _ _ _ _ a a a //
		// expect: a a a a _ _ _ _ _ _ _ _ _ _ a a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 13; i++) {
			deque.removeFirst();
		}
		for (int i = 0; i < 6; i++) {
			deque.offer("a");
		}
		deque.set(3, collection.get(0));
		deque.set(4, collection.get(1));

		deque.removeAll(collection);
		data = getInternalArray(deque);
		expected = new Object[] {"a", "a", "a", "a", null, null, null, null, null, null, null, null, null,
				null, "a", "a" };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a ? ? a a a _ _ _ _ _ _ _ _ a a //
		// expect: a a a a a _ _ _ _ _ _ _ _ _ _ a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 14; i++) {
			deque.removeFirst();
		}
		for (int i = 0; i < 7; i++) {
			deque.offer("a");
		}
		deque.set(3, collection.get(0));
		deque.set(4, collection.get(1));

		deque.removeAll(collection);
		data = getInternalArray(deque);
		expected = new Object[] {"a", "a", "a", "a", "a", null, null, null, null, null, null, null, null,
				null, null, "a" };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a a ? ? a a a _ _ _ _ _ _ _ _ a //
		// expect: a a a a a a _ _ _ _ _ _ _ _ _ _ //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		deque.removeFirst();
		deque.offer("a");
		for (int i = 0; i < 14; i++) {
			deque.removeFirst();
		}
		for (int i = 0; i < 7; i++) {
			deque.offer("a");
		}
		deque.set(3, collection.get(0));
		deque.set(4, collection.get(1));

		deque.removeAll(collection);
		data = getInternalArray(deque);
		expected = new Object[] {"a", "a", "a", "a", "a", "a", null, null, null, null, null, null, null,
				null, null, null };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a a a ? ? a a a _ _ _ _ _ _ _ _ //
		// expect: _ a a a a a a _ _ _ _ _ _ _ _ _ //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 8; i++) {
			deque.offer("a");
		}
		deque.set(3, collection.get(0));
		deque.set(4, collection.get(1));

		deque.removeAll(collection);
		data = getInternalArray(deque);
		expected = new Object[] {null, "a", "a", "a", "a", "a", "a", null, null, null, null, null, null,
				null, null, null };
		assertEqualContent(expected, data);
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#removeAll(Collection)} with the given Collection. For
	 * the sake of this test, all collections will have a size of 2.
	 * 
	 * @param collection
	 *            Collection to remove from the deque.
	 */
	private void internalTestRemoveAllLeftRotate(List<Object> collection) {
		// //////////////////////////////////////////
		// Array : _ _ _ _ _ _ _ _ a a a a ? ? a a //
		// expect: _ _ _ _ _ _ _ _ a a a a a a _ _ //
		// //////////////////////////////////////////
		Deque<Object> deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 12; i++) {
			deque.offer("a");
		}
		deque.addAll(collection);
		for (int i = 0; i < 8; i++) {
			deque.removeFirst();
		}
		for (int i = 0; i < 2; i++) {
			deque.offer("a");
		}

		deque.removeAll(collection);
		Object[] data = getInternalArray(deque);
		Object[] expected = new Object[] {null, null, null, null, null, null, null, null, "a", "a", "a", "a",
				"a", "a", null, null };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a _ _ _ _ _ _ _ _ a a a a ? ? a //
		// expect: _ _ _ _ _ _ _ _ _ a a a a a a _ //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 13; i++) {
			deque.offer("a");
		}
		deque.addAll(collection);
		for (int i = 0; i < 9; i++) {
			deque.removeFirst();
		}
		for (int i = 0; i < 2; i++) {
			deque.offer("a");
		}

		deque.removeAll(collection);
		data = getInternalArray(deque);
		expected = new Object[] {null, null, null, null, null, null, null, null, null, "a", "a", "a", "a",
				"a", "a", null };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a a _ _ _ _ _ _ a a a a a ? ? a //
		// expect: _ _ _ _ _ _ _ _ a a a a a a a a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 13; i++) {
			deque.offer("a");
		}
		deque.addAll(collection);
		for (int i = 0; i < 8; i++) {
			deque.removeFirst();
		}
		for (int i = 0; i < 3; i++) {
			deque.offer("a");
		}

		deque.removeAll(collection);
		data = getInternalArray(deque);
		expected = new Object[] {null, null, null, null, null, null, null, null, "a", "a", "a", "a", "a",
				"a", "a", "a" };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a a a _ _ _ _ _ _ a a a a a ? ? //
		// expect: a _ _ _ _ _ _ _ _ a a a a a a a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 14; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 9; i++) {
			deque.removeFirst();
		}
		deque.addAll(collection);
		for (int i = 0; i < 3; i++) {
			deque.offer("a");
		}

		deque.removeAll(collection);
		data = getInternalArray(deque);
		expected = new Object[] {"a", null, null, null, null, null, null, null, null, "a", "a", "a", "a",
				"a", "a", "a" };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : ? a a a _ _ _ _ _ _ a a a a a ? //
		// expect: a a _ _ _ _ _ _ _ _ a a a a a a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 10; i++) {
			deque.removeFirst();
		}
		deque.addAll(collection);
		for (int i = 0; i < 3; i++) {
			deque.offer("a");
		}

		deque.removeAll(collection);
		data = getInternalArray(deque);
		expected = new Object[] {"a", "a", null, null, null, null, null, null, null, null, "a", "a", "a",
				"a", "a", "a" };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : ? ? a a _ _ _ _ _ _ _ a a a a a //
		// expect: a a _ _ _ _ _ _ _ _ _ a a a a a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 11; i++) {
			deque.removeFirst();
		}
		deque.offer("a");
		deque.addAll(collection);
		deque.offer("a");
		deque.offer("a");

		deque.removeAll(collection);
		data = getInternalArray(deque);
		expected = new Object[] {"a", "a", null, null, null, null, null, null, null, null, null, "a", "a",
				"a", "a", "a" };
		assertEqualContent(expected, data);
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#removeAll(Collection)} with the given Collection. For
	 * the sake of this test, all collections will have a size of 2.
	 * 
	 * @param collection
	 *            Collection to remove from the deque.
	 */
	private void internalTestRemoveAllRightRotate(List<Object> collection) {
		// //////////////////////////////////////////
		// Array : _ _ _ _ _ _ a a ? ? a a a a _ _ //
		// expect: _ _ _ _ _ _ _ _ a a a a a a _ _ //
		// //////////////////////////////////////////
		Deque<Object> deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 8; i++) {
			deque.offer("a");
		}
		deque.addAll(collection);
		for (int i = 0; i < 4; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 6; i++) {
			deque.removeFirst();
		}

		deque.removeAll(collection);
		Object[] data = getInternalArray(deque);
		Object[] expected = new Object[] {null, null, null, null, null, null, null, null, "a", "a", "a", "a",
				"a", "a", null, null };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a ? ? a a a a _ _ _ _ _ _ _ _ a //
		// expect: _ a a a a a a _ _ _ _ _ _ _ _ _ //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		deque.removeFirst();
		deque.offer("a");
		for (int i = 0; i < 14; i++) {
			deque.removeFirst();
		}
		deque.offer("a");
		deque.addAll(collection);
		for (int i = 0; i < 4; i++) {
			deque.offer("a");
		}

		deque.removeAll(collection);
		data = getInternalArray(deque);
		expected = new Object[] {null, "a", "a", "a", "a", "a", "a", null, null, null, null, null, null,
				null, null, null };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a ? ? a a a a _ _ _ _ _ _ _ a a //
		// expect: a a a a a a a _ _ _ _ _ _ _ _ _ //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 14; i++) {
			deque.removeFirst();
		}
		deque.offer("a");
		deque.offer("a");
		deque.addAll(collection);
		for (int i = 0; i < 4; i++) {
			deque.offer("a");
		}

		deque.removeAll(collection);
		data = getInternalArray(deque);
		expected = new Object[] {"a", "a", "a", "a", "a", "a", "a", null, null, null, null, null, null, null,
				null, null };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : ? ? a a a a _ _ _ _ _ _ _ a a a //
		// expect: a a a a a a _ _ _ _ _ _ _ _ _ a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 13; i++) {
			deque.removeFirst();
		}
		deque.offer("a");
		deque.addAll(collection);
		for (int i = 0; i < 4; i++) {
			deque.offer("a");
		}

		deque.removeAll(collection);
		data = getInternalArray(deque);
		expected = new Object[] {"a", "a", "a", "a", "a", "a", null, null, null, null, null, null, null,
				null, null, "a" };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : ? a a a a _ _ _ _ _ _ _ a a a ? //
		// expect: a a a a a _ _ _ _ _ _ _ _ _ a a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 12; i++) {
			deque.removeFirst();
		}
		deque.addAll(collection);
		for (int i = 0; i < 4; i++) {
			deque.offer("a");
		}

		deque.removeAll(collection);
		data = getInternalArray(deque);
		expected = new Object[] {"a", "a", "a", "a", "a", null, null, null, null, null, null, null, null,
				null, "a", "a" };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a a a a _ _ _ _ _ _ _ a a a ? ? //
		// expect: a a a a _ _ _ _ _ _ _ _ _ a a a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 14; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 11; i++) {
			deque.removeFirst();
		}
		deque.addAll(collection);
		for (int i = 0; i < 4; i++) {
			deque.offer("a");
		}

		deque.removeAll(collection);
		data = getInternalArray(deque);
		expected = new Object[] {"a", "a", "a", "a", null, null, null, null, null, null, null, null, null,
				"a", "a", "a" };
		assertEqualContent(expected, data);
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#remove(Object)} with the given element.
	 * 
	 * @param element
	 *            Element to remove from the deque.
	 */
	private void internalTestRemoveLeftRotate(Object element) {
		// //////////////////////////////////////////
		// Array : _ _ _ _ _ _ _ _ a a a a ? a a a //
		// expect: _ _ _ _ _ _ _ _ a a a a a a a _ //
		// //////////////////////////////////////////
		Deque<Object> deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 12; i++) {
			deque.offer("a");
		}
		deque.offer(element);
		for (int i = 0; i < 8; i++) {
			deque.removeFirst();
		}
		for (int i = 0; i < 3; i++) {
			deque.offer("a");
		}

		deque.remove(element);
		Object[] data = getInternalArray(deque);
		Object[] expected = new Object[] {null, null, null, null, null, null, null, null, "a", "a", "a", "a",
				"a", "a", "a", null };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a _ _ _ _ _ _ _ _ a a a a ? a a //
		// expect: _ _ _ _ _ _ _ _ _ a a a a a a a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 13; i++) {
			deque.offer("a");
		}
		deque.offer(element);
		for (int i = 0; i < 9; i++) {
			deque.removeFirst();
		}
		for (int i = 0; i < 3; i++) {
			deque.offer("a");
		}

		deque.remove(element);
		data = getInternalArray(deque);
		expected = new Object[] {null, null, null, null, null, null, null, null, null, "a", "a", "a", "a",
				"a", "a", "a" };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a a a _ _ _ _ _ _ _ _ a a a a ? //
		// expect: a a _ _ _ _ _ _ _ _ _ a a a a a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 11; i++) {
			deque.removeFirst();
		}
		deque.offer(element);
		for (int i = 0; i < 3; i++) {
			deque.offer("a");
		}

		deque.remove(element);
		data = getInternalArray(deque);
		expected = new Object[] {"a", "a", null, null, null, null, null, null, null, null, null, "a", "a",
				"a", "a", "a" };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : ? a a a _ _ _ _ _ _ _ _ a a a a //
		// expect: a a a _ _ _ _ _ _ _ _ _ a a a a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 12; i++) {
			deque.removeFirst();
		}
		deque.offer("a");
		deque.offer(element);
		for (int i = 0; i < 3; i++) {
			deque.offer("a");
		}

		deque.remove(element);
		data = getInternalArray(deque);
		expected = new Object[] {"a", "a", "a", null, null, null, null, null, null, null, null, null, "a",
				"a", "a", "a" };
		assertEqualContent(expected, data);
	}

	/**
	 * Tests the behavior of {@link CircularArrayDeque#remove(Object)} with the given element.
	 * 
	 * @param element
	 *            Element to remove from the deque.
	 */
	private void internalTestRemoveRightRotate(Object element) {
		// //////////////////////////////////////////
		// Array : _ _ _ _ _ _ _ a a a ? a a a a _ //
		// expect: _ _ _ _ _ _ _ _ a a a a a a a _ //
		// //////////////////////////////////////////
		Deque<Object> deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 10; i++) {
			deque.offer("a");
		}
		deque.offer(element);
		for (int i = 0; i < 7; i++) {
			deque.removeFirst();
		}
		for (int i = 0; i < 4; i++) {
			deque.offer("a");
		}

		deque.remove(element);
		Object[] data = getInternalArray(deque);
		Object[] expected = new Object[] {null, null, null, null, null, null, null, null, "a", "a", "a", "a",
				"a", "a", "a", null };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a a ? a a a a _ _ _ _ _ _ _ _ a //
		// expect: a a a a a a a _ _ _ _ _ _ _ _ _ //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 14; i++) {
			deque.removeFirst();
		}
		deque.offer("a");
		deque.removeFirst();
		for (int i = 0; i < 2; i++) {
			deque.offer("a");
		}
		deque.offer(element);
		for (int i = 0; i < 4; i++) {
			deque.offer("a");
		}

		deque.remove(element);
		data = getInternalArray(deque);
		expected = new Object[] {"a", "a", "a", "a", "a", "a", "a", null, null, null, null, null, null, null,
				null, null };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : ? a a a a _ _ _ _ _ _ _ _ a a a //
		// expect: a a a a a _ _ _ _ _ _ _ _ _ a a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 13; i++) {
			deque.removeFirst();
		}
		deque.offer("a");
		deque.offer(element);
		for (int i = 0; i < 4; i++) {
			deque.offer("a");
		}

		deque.remove(element);
		data = getInternalArray(deque);
		expected = new Object[] {"a", "a", "a", "a", "a", null, null, null, null, null, null, null, null,
				null, "a", "a" };
		assertEqualContent(expected, data);

		// //////////////////////////////////////////
		// Array : a a a a _ _ _ _ _ _ _ _ a a a ? //
		// expect: a a a a _ _ _ _ _ _ _ _ _ a a a //
		// //////////////////////////////////////////
		deque = new CircularArrayDeque<Object>();

		for (int i = 0; i < 15; i++) {
			deque.offer("a");
		}
		for (int i = 0; i < 12; i++) {
			deque.removeFirst();
		}
		deque.offer(element);
		for (int i = 0; i < 4; i++) {
			deque.offer("a");
		}

		deque.remove(element);
		data = getInternalArray(deque);
		expected = new Object[] {"a", "a", "a", "a", null, null, null, null, null, null, null, null, null,
				"a", "a", "a" };
		assertEqualContent(expected, data);
	}

	/**
	 * Returns a list containing <code>size</code> random Integers.
	 * 
	 * @param size
	 *            Size of the list to create.
	 * @param excluded
	 *            Values that cannot be in our returned list.
	 * @return A list containing <code>size</code> random Integers.
	 */
	private List<Integer> randomIntegerListNotIn(int size, Collection<?> excluded) {
		List<Integer> list = new ArrayList<Integer>(size);
		for (int i = 0; i < size; i++) {
			Integer integer = getRandomInteger();
			while (list.contains(integer) || excluded.contains(integer)) {
				integer = getRandomInteger();
			}
			list.add(integer);
		}
		return list;
	}

	/**
	 * Returns a list containing <code>size</code> random Strings.
	 * 
	 * @param size
	 *            Size of the list to create.
	 * @param excluded
	 *            Values that cannot be in our returned list.
	 * @return A list containing <code>size</code> random Strings.
	 */
	private List<String> randomStringListNotIn(int size, Collection<?> excluded) {
		List<String> list = new ArrayList<String>(size);
		for (int i = 0; i < size; i++) {
			String string = getRandomString();
			while (list.contains(string) || excluded.contains(string)) {
				string = getRandomString();
			}
			list.add(string);
		}
		return list;
	}

	/**
	 * Returns a deque containing <code>size</code> random Strings.
	 * 
	 * @param size
	 *            Size of the deque to create.
	 * @param excluded
	 *            Values that cannot be in our returned list.
	 * @return A deque containing <code>size</code> random Strings.
	 */
	private Deque<String> randomStringDequeNotIn(int size, Collection<?> excluded) {
		Deque<String> deque = new CircularArrayDeque<String>(size);
		for (int i = 0; i < size; i++) {
			String s = getRandomString();
			while (deque.contains(s) || excluded.contains(s)) {
				s = getRandomString();
			}
			deque.add(s);
		}
		return deque;
	}

	/**
	 * Returns a set containing <code>size</code> random Strings.
	 * 
	 * @param size
	 *            Size of the set to create.
	 * @param excluded
	 *            Values that cannot be in our returned list.
	 * @return A set containing <code>size</code> random Strings.
	 */
	private Set<String> randomStringSetNotIn(int size, Collection<?> excluded) {
		Set<String> set = new HashSet<String>(size);
		for (int i = 0; i < size; i++) {
			String s = getRandomString();
			while (set.contains(s) || excluded.contains(s)) {
				s = getRandomString();
			}
			set.add(s);
		}
		return set;
	}

	/**
	 * Reads a Deque from the given string.
	 * 
	 * @param serialized
	 *            The serialized deque we are to read.
	 * @return The read Deque.
	 */
	@SuppressWarnings("unchecked")
	private Deque<Object> readDeque(byte[] serialized) {
		try {
			InputStream bais = new ByteArrayInputStream(serialized);
			ObjectInputStream stream = new ObjectInputStream(bais);
			Object read = stream.readObject();
			stream.close();
			if (read instanceof Deque<?>) {
				return (Deque<Object>)read;
			}
			fail("The read Object wasn't a Deque"); //$NON-NLS-1$
		} catch (ClassNotFoundException e) {
			fail("Unexpected ClassNotFoundException thrown"); //$NON-NLS-1$
		} catch (IOException e) {
			fail("Unexpected IOException thrown"); //$NON-NLS-1$	
		}
		return null;
	}

	/**
	 * Serializes the given deque to a String.
	 * 
	 * @param deque
	 *            The deque we are to serialize.
	 * @return The serialized deque.
	 */
	private byte[] writeDeque(Deque<Object> deque) {
		try {
			ByteArrayOutputStream baos = new ByteArrayOutputStream();
			ObjectOutputStream stream = new ObjectOutputStream(baos);
			stream.writeObject(deque);
			stream.close();
			return baos.toByteArray();
		} catch (IOException e) {
			fail("Unexpected IOException thrown"); //$NON-NLS-1$
		}
		return new byte[0];
	}
}