/*******************************************************************************
 * Copyright (c) 2011, 2015 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License 2.0, which accompanies this distribution
 * and is available at https://www.eclipse.org/legal/epl-2.0/.
 * 
 * Contributors:
 *     Oracle - initial API and implementation
 ******************************************************************************/
package org.eclipse.jpt.common.utility.tests.internal.collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;

import junit.framework.TestCase;

import org.eclipse.jpt.common.utility.internal.collection.CollectionTools;

@SuppressWarnings("nls")
public abstract class AbstractRepeatingElementListTests
	extends TestCase
{
	public AbstractRepeatingElementListTests(String name) {
		super(name);
	}

	public void testBogusSize() {
		boolean exCaught = false;
		try {
			List<String> list = this.buildList(-3);
			fail("bogus list: " + list);
		} catch (IllegalArgumentException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);
	}

	public void testAddObject() {
		List<String> list = this.buildList(3);
		boolean exCaught = false;
		try {
			list.add("foo");
			fail("bogus list: " + list);
		} catch (UnsupportedOperationException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);
	}

	public void testAddIntObject() {
		List<String> list = this.buildList(3);
		boolean exCaught = false;
		try {
			list.add(2, "foo");
			fail("bogus list: " + list);
		} catch (UnsupportedOperationException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);
	}

	public void testAddAllCollection() {
		List<String> list = this.buildList(3);
		list.addAll(Collections.<String>emptySet());

		boolean exCaught = false;
		try {
			list.addAll(CollectionTools.hashBag("foo", "bar"));
			fail("bogus list: " + list);
		} catch (UnsupportedOperationException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);
	}

	public void testAddAllIntCollection() {
		List<String> list = this.buildList(3);
		list.addAll(1, Collections.<String>emptySet());

		boolean exCaught = false;
		try {
			list.addAll(1, CollectionTools.hashBag("foo", "bar"));
			fail("bogus list: " + list);
		} catch (UnsupportedOperationException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);
	}

	public void testClear() {
		List<String> list = this.buildList(0);
		list.clear();

		list = this.buildList(3);
		boolean exCaught = false;
		try {
			list.clear();
			fail("bogus list: " + list);
		} catch (UnsupportedOperationException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);
	}

	public void testContainsObject() {
		List<String> list = this.buildList(0);
		assertFalse(list.contains(this.getElement()));
		assertFalse(list.contains(new Object()));

		list = this.buildList(3);
		assertTrue(list.contains(this.getElement()));
		assertFalse(list.contains(new Object()));
	}

	public void testContainsAllCollection() {
		Collection<String> emptyCollection = Collections.emptySet();

		Collection<String> goodCollection = new ArrayList<String>();
		goodCollection.add(this.getElement());
		goodCollection.add(this.getElement());
		goodCollection.add(this.getElement());

		Collection<String> badCollection = new ArrayList<String>();
		badCollection.add(this.getElement());
		badCollection.add("bad");
		badCollection.add(this.getElement());

		List<String> list = this.buildList(0);
		assertTrue(list.containsAll(emptyCollection));
		assertFalse(list.containsAll(goodCollection));
		assertFalse(list.containsAll(badCollection));

		list = this.buildList(3);
		assertTrue(list.containsAll(emptyCollection));
		assertTrue(list.containsAll(goodCollection));
		assertFalse(list.containsAll(badCollection));
	}

	public void testGetInt() {
		List<String> list = this.buildList(3);
		assertEquals(this.getElement(), list.get(0));
		assertEquals(this.getElement(), list.get(1));
		assertEquals(this.getElement(), list.get(2));

		boolean exCaught = false;
		try {
			fail("bogus element: " + list.get(-1));
		} catch (IndexOutOfBoundsException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);

		exCaught = false;
		try {
			fail("bogus element: " + list.get(3));
		} catch (IndexOutOfBoundsException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);
	}

	public void testIndexOfObject() {
		List<String> list = this.buildList(3);
		assertEquals(0, list.indexOf(this.getElement()));
		assertEquals(-1, list.indexOf(new Object()));

		list = this.buildList(0);
		assertEquals(-1, list.indexOf(this.getElement()));
	}

	public void testIsEmpty() {
		List<String> list = this.buildList(3);
		assertFalse(list.isEmpty());

		list = this.buildList(0);
		assertTrue(list.isEmpty());
	}

	public void testIterator() {
		List<String> list = this.buildList(3);
		Iterator<String> iterator = list.iterator();
		assertTrue(iterator.hasNext());
		assertEquals(this.getElement(), iterator.next());
		assertTrue(iterator.hasNext());
		assertEquals(this.getElement(), iterator.next());
		assertTrue(iterator.hasNext());
		assertEquals(this.getElement(), iterator.next());
		assertFalse(iterator.hasNext());

		boolean exCaught = false;
		try {
			iterator.remove();
			fail("bogus list: " + list);
		} catch (UnsupportedOperationException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);

		list = this.buildList(0);
		iterator = list.iterator();
		assertFalse(iterator.hasNext());
	}

	public void testLastIndexOfObject() {
		List<String> list = this.buildList(3);
		assertEquals(2, list.lastIndexOf(this.getElement()));
		assertEquals(-1, list.lastIndexOf(new Object()));

		list = this.buildList(0);
		assertEquals(-1, list.indexOf(this.getElement()));
		assertEquals(-1, list.lastIndexOf(new Object()));
	}

	public void testListIterator() {
		List<String> list = this.buildList(3);
		ListIterator<String> iterator = list.listIterator();
		this.verifyListIterator(list, iterator);

		list = this.buildList(0);
		iterator = list.listIterator();
		assertFalse(iterator.hasNext());
		assertFalse(iterator.hasPrevious());
	}

	public void testListIteratorInt() {
		List<String> list = this.buildList(7);
		ListIterator<String> iterator = list.listIterator(4);
		this.verifyListIterator(list, iterator);

		list = this.buildList(0);
		iterator = list.listIterator();
		assertFalse(iterator.hasNext());
		assertFalse(iterator.hasPrevious());
	}

	public void verifyListIterator(List<String> list, ListIterator<String> iterator) {
		assertTrue(iterator.hasNext());
		assertFalse(iterator.hasPrevious());
		assertEquals(0, iterator.nextIndex());
		assertEquals(-1, iterator.previousIndex());
		assertEquals(this.getElement(), iterator.next());

		assertTrue(iterator.hasNext());
		assertTrue(iterator.hasPrevious());
		assertEquals(1, iterator.nextIndex());
		assertEquals(0, iterator.previousIndex());
		assertEquals(this.getElement(), iterator.next());

		assertTrue(iterator.hasNext());
		assertTrue(iterator.hasPrevious());
		assertEquals(2, iterator.nextIndex());
		assertEquals(1, iterator.previousIndex());
		assertEquals(this.getElement(), iterator.next());

		assertFalse(iterator.hasNext());
		assertTrue(iterator.hasPrevious());
		assertEquals(3, iterator.nextIndex());
		assertEquals(2, iterator.previousIndex());
		boolean exCaught = false;
		try {
			fail("bogus element: " + iterator.next());
		} catch (NoSuchElementException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);
		assertEquals(this.getElement(), iterator.previous());

		assertTrue(iterator.hasNext());
		assertTrue(iterator.hasPrevious());
		assertEquals(2, iterator.nextIndex());
		assertEquals(1, iterator.previousIndex());
		assertEquals(this.getElement(), iterator.previous());

		assertTrue(iterator.hasNext());
		assertTrue(iterator.hasPrevious());
		assertEquals(1, iterator.nextIndex());
		assertEquals(0, iterator.previousIndex());
		assertEquals(this.getElement(), iterator.previous());

		assertTrue(iterator.hasNext());
		assertFalse(iterator.hasPrevious());
		assertEquals(0, iterator.nextIndex());
		assertEquals(-1, iterator.previousIndex());
		exCaught = false;
		try {
			fail("bogus element: " + iterator.previous());
		} catch (NoSuchElementException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);

		exCaught = false;
		try {
			iterator.remove();
			fail("bogus list: " + list);
		} catch (UnsupportedOperationException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);


		exCaught = false;
		try {
			iterator.add("foo");
			fail("bogus list: " + list);
		} catch (UnsupportedOperationException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);


		exCaught = false;
		try {
			iterator.set("foo");
			fail("bogus list: " + list);
		} catch (UnsupportedOperationException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);

		list = this.buildList(0);
		iterator = list.listIterator();
		assertFalse(iterator.hasNext());
		assertFalse(iterator.hasPrevious());
	}

	public void testRemoveObject() {
		List<String> list = this.buildList(0);
		assertFalse(list.remove(this.getElement()));
		assertFalse(list.remove("foo"));

		list = this.buildList(3);
		assertFalse(list.remove("foo"));
		boolean exCaught = false;
		try {
			list.remove(this.getElement());
			fail("bogus list: " + list);
		} catch (UnsupportedOperationException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);
	}

	public void testRemoveInt() {
		List<String> list = this.buildList(3);
		boolean exCaught = false;
		try {
			list.remove(0);
			fail("bogus list: " + list);
		} catch (UnsupportedOperationException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);
	}

	public void testRemoveAllCollection() {
		Collection<String> emptyCollection = Collections.emptySet();

		Collection<String> goodCollection = new ArrayList<String>();
		goodCollection.add("good");
		goodCollection.add("good");
		goodCollection.add("good");

		Collection<String> badCollection = new ArrayList<String>();
		badCollection.add("bad");
		badCollection.add(this.getElement());
		badCollection.add("bad");

		List<String> list = this.buildList(0);
		assertFalse(list.removeAll(emptyCollection));
		assertFalse(list.removeAll(goodCollection));
		assertFalse(list.removeAll(badCollection));

		list = this.buildList(3);
		assertFalse(list.removeAll(emptyCollection));
		assertFalse(list.removeAll(goodCollection));
		boolean exCaught = false;
		try {
			list.removeAll(badCollection);
			fail("bogus list: " + list);
		} catch (UnsupportedOperationException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);
	}

	public void testRetainAllCollection() {
		Collection<String> emptyCollection = Collections.emptySet();

		Collection<String> goodCollection = new ArrayList<String>();
		goodCollection.add("good");
		goodCollection.add(this.getElement());
		goodCollection.add("good");

		Collection<String> badCollection = new ArrayList<String>();
		badCollection.add("bad");
		badCollection.add("bad");
		badCollection.add("bad");

		List<String> list = this.buildList(0);
		assertFalse(list.retainAll(emptyCollection));
		assertFalse(list.retainAll(goodCollection));
		assertFalse(list.retainAll(badCollection));

		list = this.buildList(3);
		boolean exCaught = false;
		try {
			list.retainAll(emptyCollection);
			fail("bogus list: " + list);
		} catch (UnsupportedOperationException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);
		assertFalse(list.retainAll(goodCollection));
		exCaught = false;
		try {
			list.retainAll(badCollection);
			fail("bogus list: " + list);
		} catch (UnsupportedOperationException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);
	}

	public void testSetIntObject() {
		List<String> list = this.buildList(3);
		boolean exCaught = false;
		try {
			list.set(0, "foo");
			fail("bogus list: " + list);
		} catch (UnsupportedOperationException ex) {
			exCaught = true;
		}
		assertTrue(exCaught);
	}

	public void testSize() {
		List<String> list = this.buildList(3);
		assertEquals(3, list.size());
	}

	public void testSubList() {
		List<String> list = this.buildList(7);
		List<String> subList = list.subList(2, 7);
		assertEquals(5, subList.size());
		assertEquals(this.getElement(), subList.get(0));
		assertEquals(this.getElement(), subList.get(3));
		assertEquals(this.getElement(), subList.get(4));
	}

	public void testToArray() {
		List<String> list = this.buildList(7);
		Object[] array = list.toArray();
		assertEquals(7, array.length);
		assertEquals(this.getElement(), array[0]);
		assertEquals(this.getElement(), array[3]);
		assertEquals(this.getElement(), array[6]);
	}

	public void testToArrayObjectArray() {
		List<String> list = this.buildList(7);
		String[] array = list.toArray(new String[0]);
		assertEquals(7, array.length);
		assertEquals(this.getElement(), array[0]);
		assertEquals(this.getElement(), array[3]);
		assertEquals(this.getElement(), array[6]);

		String[] template = new String[21];
		array = list.toArray(template);
		assertSame(template, array);
		assertEquals(21, array.length);
		assertEquals(this.getElement(), array[0]);
		assertEquals(this.getElement(), array[3]);
		assertEquals(this.getElement(), array[6]);
		assertNull(array[7]);
		assertNull(array[20]);
	}

	public void testToString() {
		List<String> list1 = this.buildList(3);
		List<String> list2 = new ArrayList<String>();
		list2.add(this.getElement());
		list2.add(this.getElement());
		list2.add(this.getElement());
		assertEquals(list2.toString(), list1.toString());

		list1 = this.buildList(0);
		list2 = new ArrayList<String>();
		assertEquals(list2.toString(), list1.toString());
	}

	public abstract List<String> buildList(int size);

	public abstract String getElement();
}