common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/iterators/SynchronizedListIteratorTests.java - dali/webtools.dali - Git at Google

 /*******************************************************************************
  * Copyright (c) 2009, 2010 Oracle. All rights reserved.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0, which accompanies this distribution
  * and is available at http://www.eclipse.org/legal/epl-v10.html.
  *
  * Contributors:
  *     Oracle - initial API and implementation
  ******************************************************************************/
 package org.eclipse.jpt.common.utility.tests.internal.iterators;

 import java.util.Iterator;
 import java.util.ListIterator;
 import java.util.NoSuchElementException;

 import org.eclipse.jpt.common.utility.internal.iterators.SynchronizedListIterator;
 import org.eclipse.jpt.common.utility.tests.internal.TestTools;

 @SuppressWarnings("nls")
 public class SynchronizedListIteratorTests
 	extends SynchronizedIteratorTests
 {
 	public SynchronizedListIteratorTests(String name) {
 		super(name);
 	}

 	public void testUnsynchronizedPrevious() throws Exception {
 		TestListIterator<String> iterator = this.buildTestIterator(TWO_TICKS);
 		iterator.next();
 		iterator.next();

 		PreviousTestRunnable<String> runnable1 = new PreviousTestRunnable<String>(iterator);
 		Thread thread1 = this.buildThread(runnable1);
 		PreviousTestRunnable<String> runnable2 = new PreviousTestRunnable<String>(iterator);
 		Thread thread2 = this.buildThread(runnable2);
 		iterator.slowThread = thread1;

 		thread1.start();

 		// allow thread 1 to read the first element and get bogged down
 		this.sleep(TICK);
 		thread2.start();

 		// wait for the threads to finish
 		thread1.join();
 		thread2.join();

 		// both threads should have read the same element from the iterator :-(
 		assertEquals("bar", runnable1.previous);
 		assertEquals("bar", runnable2.previous);
 	}

 	public void testSynchronizedPrevious() throws Exception {
 		TestListIterator<String> nestedIterator = this.buildTestIterator(TWO_TICKS);
 		ListIterator<String> iterator = this.buildSynchronizedIterator(nestedIterator);
 		iterator.next();
 		iterator.next();

 		PreviousTestRunnable<String> runnable1 = new PreviousTestRunnable<String>(iterator);
 		Thread thread1 = this.buildThread(runnable1);
 		PreviousTestRunnable<String> runnable2 = new PreviousTestRunnable<String>(iterator);
 		Thread thread2 = this.buildThread(runnable2);
 		nestedIterator.slowThread = thread1;

 		thread1.start();

 		// allow thread 1 to read the first element and get bogged down
 		this.sleep(TICK);
 		thread2.start();

 		// wait for the threads to finish
 		thread1.join();
 		thread2.join();

 		// the threads should have read the correct elements from the iterator :-)
 		assertEquals("bar", runnable1.previous);
 		assertEquals("foo", runnable2.previous);
 	}

 	public void testUnsynchronizedHasPrevious() throws Exception {
 		TestListIterator<String> iterator = this.buildTestIterator(TWO_TICKS);
 		iterator.next();

 		PreviousTestRunnable<String> runnable1 = new PreviousTestRunnable<String>(iterator);
 		Thread thread1 = this.buildThread(runnable1);
 		HasPreviousTestRunnable<String> runnable2 = new HasPreviousTestRunnable<String>(iterator);
 		Thread thread2 = this.buildThread(runnable2);
 		iterator.slowThread = thread1;

 		thread1.start();

 		// allow thread 1 to read the first element and get bogged down
 		this.sleep(TICK);
 		thread2.start();

 		// wait for the threads to finish
 		thread1.join();
 		thread2.join();

 		// thread 1 will have the first element,
 		// but thread 2 will think there are more "previous" elements on the iterator :-(
 		assertEquals("foo", runnable1.previous);
 		assertEquals(true, runnable2.hasPrevious);
 	}

 	public void testSynchronizedHasPrevious() throws Exception {
 		TestListIterator<String> nestedIterator = this.buildTestIterator(TWO_TICKS);
 		ListIterator<String> iterator = this.buildSynchronizedIterator(nestedIterator);
 		iterator.next();

 		PreviousTestRunnable<String> runnable1 = new PreviousTestRunnable<String>(iterator);
 		Thread thread1 = this.buildThread(runnable1);
 		HasPreviousTestRunnable<String> runnable2 = new HasPreviousTestRunnable<String>(iterator);
 		Thread thread2 = this.buildThread(runnable2);
 		nestedIterator.slowThread = thread1;

 		thread1.start();

 		// allow thread 1 to read the first element and get bogged down
 		this.sleep(TICK);
 		thread2.start();

 		// wait for the threads to finish
 		thread1.join();
 		thread2.join();

 		// thread 1 will have the first element,
 		// and thread 2 will think there are no more "previous" elements on the iterator :-)
 		assertEquals("foo", runnable1.previous);
 		assertEquals(false, runnable2.hasPrevious);
 	}

 	public void testUnsynchronizedNextIndex() throws Exception {
 		TestListIterator<String> iterator = this.buildTestIterator(TWO_TICKS);

 		NextTestRunnable<String> runnable1 = new NextTestRunnable<String>(iterator);
 		Thread thread1 = this.buildThread(runnable1);
 		NextIndexTestRunnable<String> runnable2 = new NextIndexTestRunnable<String>(iterator);
 		Thread thread2 = this.buildThread(runnable2);
 		iterator.slowThread = thread1;

 		thread1.start();

 		// allow thread 1 to read the first element and get bogged down
 		this.sleep(TICK);
 		thread2.start();

 		// wait for the threads to finish
 		thread1.join();
 		thread2.join();

 		// thread 1 will have the first element,
 		// but thread 2 will think the next index is still 0 :-(
 		assertEquals("foo", runnable1.next);
 		assertEquals(0, runnable2.nextIndex);
 	}

 	public void testSynchronizedNextIndex() throws Exception {
 		TestListIterator<String> nestedIterator = this.buildTestIterator(TWO_TICKS);
 		ListIterator<String> iterator = this.buildSynchronizedIterator(nestedIterator);

 		NextTestRunnable<String> runnable1 = new NextTestRunnable<String>(iterator);
 		Thread thread1 = this.buildThread(runnable1);
 		NextIndexTestRunnable<String> runnable2 = new NextIndexTestRunnable<String>(iterator);
 		Thread thread2 = this.buildThread(runnable2);
 		nestedIterator.slowThread = thread1;

 		thread1.start();

 		// allow thread 1 to read the first element and get bogged down
 		this.sleep(TICK);
 		thread2.start();

 		// wait for the threads to finish
 		thread1.join();
 		thread2.join();

 		// thread 1 will have the first element,
 		// and thread 2 will think the next index is 1 :-)
 		assertEquals("foo", runnable1.next);
 		assertEquals(1, runnable2.nextIndex);
 	}

 	public void testUnsynchronizedPreviousIndex() throws Exception {
 		TestListIterator<String> iterator = this.buildTestIterator(TWO_TICKS);
 		iterator.next();

 		PreviousTestRunnable<String> runnable1 = new PreviousTestRunnable<String>(iterator);
 		Thread thread1 = this.buildThread(runnable1);
 		PreviousIndexTestRunnable<String> runnable2 = new PreviousIndexTestRunnable<String>(iterator);
 		Thread thread2 = this.buildThread(runnable2);
 		iterator.slowThread = thread1;

 		thread1.start();

 		// allow thread 1 to read the first element and get bogged down
 		this.sleep(TICK);
 		thread2.start();

 		// wait for the threads to finish
 		thread1.join();
 		thread2.join();

 		// thread 1 will have the first element,
 		// but thread 2 will think the next index is still 0 :-(
 		assertEquals("foo", runnable1.previous);
 		assertEquals(0, runnable2.previousIndex);
 	}

 	public void testSynchronizedPreviousIndex() throws Exception {
 		TestListIterator<String> nestedIterator = this.buildTestIterator(TWO_TICKS);
 		ListIterator<String> iterator = this.buildSynchronizedIterator(nestedIterator);
 		iterator.next();

 		PreviousTestRunnable<String> runnable1 = new PreviousTestRunnable<String>(iterator);
 		Thread thread1 = this.buildThread(runnable1);
 		PreviousIndexTestRunnable<String> runnable2 = new PreviousIndexTestRunnable<String>(iterator);
 		Thread thread2 = this.buildThread(runnable2);
 		nestedIterator.slowThread = thread1;

 		thread1.start();

 		// allow thread 1 to read the first element and get bogged down
 		this.sleep(TICK);
 		thread2.start();

 		// wait for the threads to finish
 		thread1.join();
 		thread2.join();

 		// thread 1 will have the first element,
 		// and thread 2 will think the next index is -1 :-)
 		assertEquals("foo", runnable1.previous);
 		assertEquals(-1, runnable2.previousIndex);
 	}

 	public void testUnsynchronizedSet() throws Exception {
 		TestListIterator<String> iterator = this.buildTestIterator(TWO_TICKS);
 		iterator.next();

 		NextTestRunnable<String> runnable1 = new NextTestRunnable<String>(iterator);
 		Thread thread1 = this.buildThread(runnable1);
 		SetTestRunnable<String> runnable2 = new SetTestRunnable<String>(iterator, "xxx");
 		Thread thread2 = this.buildThread(runnable2);
 		iterator.slowThread = thread1;

 		thread1.start();

 		// allow thread 1 to read the first element and get bogged down
 		this.sleep(TICK);
 		thread2.start();

 		// wait for the threads to finish
 		thread1.join();
 		thread2.join();

 		// the wrong element was set :-(
 		assertEquals("bar", runnable1.next);
 		assertFalse(iterator.list.contains("foo"));
 		assertTrue(iterator.list.contains("xxx"));
 		assertTrue(iterator.list.contains("bar"));
 		assertTrue(iterator.list.contains("baz"));
 	}

 	public void testSynchronizedSet() throws Exception {
 		TestListIterator<String> nestedIterator = this.buildTestIterator(TWO_TICKS);
 		ListIterator<String> iterator = this.buildSynchronizedIterator(nestedIterator);
 		iterator.next();

 		NextTestRunnable<String> runnable1 = new NextTestRunnable<String>(iterator);
 		Thread thread1 = this.buildThread(runnable1);
 		SetTestRunnable<String> runnable2 = new SetTestRunnable<String>(iterator, "xxx");
 		Thread thread2 = this.buildThread(runnable2);
 		nestedIterator.slowThread = thread1;

 		thread1.start();

 		// allow thread 1 to read the first element and get bogged down
 		this.sleep(TICK);
 		thread2.start();

 		// wait for the threads to finish
 		thread1.join();
 		thread2.join();

 		// the right element was set :-)
 		assertEquals("bar", runnable1.next);
 		assertTrue(nestedIterator.list.contains("foo"));
 		assertFalse(nestedIterator.list.contains("bar"));
 		assertTrue(nestedIterator.list.contains("xxx"));
 		assertTrue(nestedIterator.list.contains("baz"));
 	}

 	public void testUnsynchronizedAdd() throws Exception {
 		TestListIterator<String> iterator = this.buildTestIterator(TWO_TICKS);
 		iterator.next();

 		NextTestRunnable<String> runnable1 = new NextTestRunnable<String>(iterator);
 		Thread thread1 = this.buildThread(runnable1);
 		AddTestRunnable<String> runnable2 = new AddTestRunnable<String>(iterator, "xxx");
 		Thread thread2 = this.buildThread(runnable2);
 		iterator.slowThread = thread1;

 		thread1.start();

 		// allow thread 1 to read the first element and get bogged down
 		this.sleep(TICK);
 		thread2.start();

 		// wait for the threads to finish
 		thread1.join();
 		thread2.join();

 		// the element was added at the wrong index :-(
 		assertEquals("bar", runnable1.next);
 		assertTrue(iterator.list.contains("foo"));
 		assertEquals(0, iterator.list.indexOf("xxx"));
 		assertTrue(iterator.list.contains("xxx"));
 		assertTrue(iterator.list.contains("bar"));
 		assertTrue(iterator.list.contains("baz"));
 	}

 	public void testSynchronizedAdd() throws Exception {
 		TestListIterator<String> nestedIterator = this.buildTestIterator(TWO_TICKS);
 		ListIterator<String> iterator = this.buildSynchronizedIterator(nestedIterator);
 		iterator.next();

 		NextTestRunnable<String> runnable1 = new NextTestRunnable<String>(iterator);
 		Thread thread1 = this.buildThread(runnable1);
 		AddTestRunnable<String> runnable2 = new AddTestRunnable<String>(iterator, "xxx");
 		Thread thread2 = this.buildThread(runnable2);
 		nestedIterator.slowThread = thread1;

 		thread1.start();

 		// allow thread 1 to read the first element and get bogged down
 		this.sleep(TICK);
 		thread2.start();

 		// wait for the threads to finish
 		thread1.join();
 		thread2.join();

 		// the element was added at the correct index :-)
 		assertEquals("bar", runnable1.next);
 		assertTrue(nestedIterator.list.contains("foo"));
 		assertEquals(1, nestedIterator.list.indexOf("xxx"));
 		assertTrue(nestedIterator.list.contains("xxx"));
 		assertTrue(nestedIterator.list.contains("bar"));
 		assertTrue(nestedIterator.list.contains("baz"));
 	}

 	@Override
 	ListIterator<String> buildSynchronizedIterator(Iterator<String> nestedIterator) {
 		return new SynchronizedListIterator<String>((ListIterator<String>) nestedIterator);
 	}

 	@Override
 	TestListIterator<String> buildTestIterator(long delay) {
 		return new TestListIterator<String>(delay, this.buildArray());
 	}

 	/**
 	 * previous runnable
 	 */
 	class PreviousTestRunnable<E> implements Runnable {
 		final ListIterator<E> iterator;
 		E previous;

 		PreviousTestRunnable(ListIterator<E> iterator) {
 			super();
 			this.iterator = iterator;
 		}

 		public void run() {
 			this.previous = this.iterator.previous();
 		}

 	}

 	/**
 	 * has previous runnable
 	 */
 	class HasPreviousTestRunnable<E> implements Runnable {
 		final ListIterator<E> iterator;
 		boolean hasPrevious;

 		HasPreviousTestRunnable(ListIterator<E> iterator) {
 			super();
 			this.iterator = iterator;
 		}

 		public void run() {
 			this.hasPrevious = this.iterator.hasPrevious();
 		}

 	}

 	/**
 	 * next index runnable
 	 */
 	class NextIndexTestRunnable<E> implements Runnable {
 		final ListIterator<E> iterator;
 		int nextIndex;

 		NextIndexTestRunnable(ListIterator<E> iterator) {
 			super();
 			this.iterator = iterator;
 		}

 		public void run() {
 			this.nextIndex = this.iterator.nextIndex();
 		}

 	}

 	/**
 	 * previous index runnable
 	 */
 	class PreviousIndexTestRunnable<E> implements Runnable {
 		final ListIterator<E> iterator;
 		int previousIndex;

 		PreviousIndexTestRunnable(ListIterator<E> iterator) {
 			super();
 			this.iterator = iterator;
 		}

 		public void run() {
 			this.previousIndex = this.iterator.previousIndex();
 		}

 	}

 	/**
 	 * set runnable
 	 */
 	class SetTestRunnable<E> implements Runnable {
 		final ListIterator<E> iterator;
 		final E element;

 		SetTestRunnable(ListIterator<E> iterator, E element) {
 			super();
 			this.iterator = iterator;
 			this.element = element;
 		}

 		public void run() {
 			this.iterator.set(this.element);
 		}

 	}

 	/**
 	 * add runnable
 	 */
 	class AddTestRunnable<E> implements Runnable {
 		final ListIterator<E> iterator;
 		final E element;

 		AddTestRunnable(ListIterator<E> iterator, E element) {
 			super();
 			this.iterator = iterator;
 			this.element = element;
 		}

 		public void run() {
 			this.iterator.add(this.element);
 		}

 	}

 	/**
 	 * Test iterator: If {@link #next()} or {@link #previous()} is called
 	 * while executing on the {@link slowThread}, the iterator will delay
 	 * for the configured time.
 	 */
 	static class TestListIterator<E> extends TestIterator<E> implements ListIterator<E> {

 		TestListIterator(long delay, E... array) {
 			super(delay, array);
 		}

 		public int nextIndex() {
 			return this.nextIndex;
 		}

 		public boolean hasPrevious() {
 			return this.nextIndex != 0;
 		}

 		public E previous() {
 			if (this.hasPrevious()) {
 				E previous = this.list.get(this.previousIndex());
 				if (Thread.currentThread() == this.slowThread) {
 					TestTools.sleep(this.delay);
 				}
 				this.nextIndex--;
 				this.lastIndex = this.nextIndex;
 				return previous;
 			}
 			throw new NoSuchElementException();
 		}

 		public int previousIndex() {
 			return this.nextIndex - 1;
 		}

 		public void set(E e) {
 			if (this.lastIndex == -1) {
 				throw new IllegalStateException();
 			}
 			this.list.set(this.lastIndex, e);
 		}

 		public void add(E e) {
 			this.list.add(this.lastIndex, e);
 			this.lastIndex++;
 			this.lastIndex = -1;
 		}

 	}

 }
	/*******************************************************************************
	* Copyright (c) 2009, 2010 Oracle. All rights reserved.
	* This program and the accompanying materials are made available under the
	* terms of the Eclipse Public License v1.0, which accompanies this distribution
	* and is available at http://www.eclipse.org/legal/epl-v10.html.
	*
	* Contributors:
	* Oracle - initial API and implementation
	******************************************************************************/
	package org.eclipse.jpt.common.utility.tests.internal.iterators;

	import java.util.Iterator;
	import java.util.ListIterator;
	import java.util.NoSuchElementException;

	import org.eclipse.jpt.common.utility.internal.iterators.SynchronizedListIterator;
	import org.eclipse.jpt.common.utility.tests.internal.TestTools;

	@SuppressWarnings("nls")
	public class SynchronizedListIteratorTests
	extends SynchronizedIteratorTests
	{
	public SynchronizedListIteratorTests(String name) {
	super(name);
	}

	public void testUnsynchronizedPrevious() throws Exception {
	TestListIterator<String> iterator = this.buildTestIterator(TWO_TICKS);
	iterator.next();
	iterator.next();

	PreviousTestRunnable<String> runnable1 = new PreviousTestRunnable<String>(iterator);
	Thread thread1 = this.buildThread(runnable1);
	PreviousTestRunnable<String> runnable2 = new PreviousTestRunnable<String>(iterator);
	Thread thread2 = this.buildThread(runnable2);
	iterator.slowThread = thread1;

	thread1.start();

	// allow thread 1 to read the first element and get bogged down
	this.sleep(TICK);
	thread2.start();

	// wait for the threads to finish
	thread1.join();
	thread2.join();

	// both threads should have read the same element from the iterator :-(
	assertEquals("bar", runnable1.previous);
	assertEquals("bar", runnable2.previous);
	}

	public void testSynchronizedPrevious() throws Exception {
	TestListIterator<String> nestedIterator = this.buildTestIterator(TWO_TICKS);
	ListIterator<String> iterator = this.buildSynchronizedIterator(nestedIterator);
	iterator.next();
	iterator.next();

	PreviousTestRunnable<String> runnable1 = new PreviousTestRunnable<String>(iterator);
	Thread thread1 = this.buildThread(runnable1);
	PreviousTestRunnable<String> runnable2 = new PreviousTestRunnable<String>(iterator);
	Thread thread2 = this.buildThread(runnable2);
	nestedIterator.slowThread = thread1;

	thread1.start();

	// allow thread 1 to read the first element and get bogged down
	this.sleep(TICK);
	thread2.start();

	// wait for the threads to finish
	thread1.join();
	thread2.join();

	// the threads should have read the correct elements from the iterator :-)
	assertEquals("bar", runnable1.previous);
	assertEquals("foo", runnable2.previous);
	}

	public void testUnsynchronizedHasPrevious() throws Exception {
	TestListIterator<String> iterator = this.buildTestIterator(TWO_TICKS);
	iterator.next();

	PreviousTestRunnable<String> runnable1 = new PreviousTestRunnable<String>(iterator);
	Thread thread1 = this.buildThread(runnable1);
	HasPreviousTestRunnable<String> runnable2 = new HasPreviousTestRunnable<String>(iterator);
	Thread thread2 = this.buildThread(runnable2);
	iterator.slowThread = thread1;

	thread1.start();

	// allow thread 1 to read the first element and get bogged down
	this.sleep(TICK);
	thread2.start();

	// wait for the threads to finish
	thread1.join();
	thread2.join();

	// thread 1 will have the first element,
	// but thread 2 will think there are more "previous" elements on the iterator :-(
	assertEquals("foo", runnable1.previous);
	assertEquals(true, runnable2.hasPrevious);
	}

	public void testSynchronizedHasPrevious() throws Exception {
	TestListIterator<String> nestedIterator = this.buildTestIterator(TWO_TICKS);
	ListIterator<String> iterator = this.buildSynchronizedIterator(nestedIterator);
	iterator.next();

	PreviousTestRunnable<String> runnable1 = new PreviousTestRunnable<String>(iterator);
	Thread thread1 = this.buildThread(runnable1);
	HasPreviousTestRunnable<String> runnable2 = new HasPreviousTestRunnable<String>(iterator);
	Thread thread2 = this.buildThread(runnable2);
	nestedIterator.slowThread = thread1;

	thread1.start();

	// allow thread 1 to read the first element and get bogged down
	this.sleep(TICK);
	thread2.start();

	// wait for the threads to finish
	thread1.join();
	thread2.join();

	// thread 1 will have the first element,
	// and thread 2 will think there are no more "previous" elements on the iterator :-)
	assertEquals("foo", runnable1.previous);
	assertEquals(false, runnable2.hasPrevious);
	}

	public void testUnsynchronizedNextIndex() throws Exception {
	TestListIterator<String> iterator = this.buildTestIterator(TWO_TICKS);

	NextTestRunnable<String> runnable1 = new NextTestRunnable<String>(iterator);
	Thread thread1 = this.buildThread(runnable1);
	NextIndexTestRunnable<String> runnable2 = new NextIndexTestRunnable<String>(iterator);
	Thread thread2 = this.buildThread(runnable2);
	iterator.slowThread = thread1;

	thread1.start();

	// allow thread 1 to read the first element and get bogged down
	this.sleep(TICK);
	thread2.start();

	// wait for the threads to finish
	thread1.join();
	thread2.join();

	// thread 1 will have the first element,
	// but thread 2 will think the next index is still 0 :-(
	assertEquals("foo", runnable1.next);
	assertEquals(0, runnable2.nextIndex);
	}

	public void testSynchronizedNextIndex() throws Exception {
	TestListIterator<String> nestedIterator = this.buildTestIterator(TWO_TICKS);
	ListIterator<String> iterator = this.buildSynchronizedIterator(nestedIterator);

	NextTestRunnable<String> runnable1 = new NextTestRunnable<String>(iterator);
	Thread thread1 = this.buildThread(runnable1);
	NextIndexTestRunnable<String> runnable2 = new NextIndexTestRunnable<String>(iterator);
	Thread thread2 = this.buildThread(runnable2);
	nestedIterator.slowThread = thread1;

	thread1.start();

	// allow thread 1 to read the first element and get bogged down
	this.sleep(TICK);
	thread2.start();

	// wait for the threads to finish
	thread1.join();
	thread2.join();

	// thread 1 will have the first element,
	// and thread 2 will think the next index is 1 :-)
	assertEquals("foo", runnable1.next);
	assertEquals(1, runnable2.nextIndex);
	}

	public void testUnsynchronizedPreviousIndex() throws Exception {
	TestListIterator<String> iterator = this.buildTestIterator(TWO_TICKS);
	iterator.next();

	PreviousTestRunnable<String> runnable1 = new PreviousTestRunnable<String>(iterator);
	Thread thread1 = this.buildThread(runnable1);
	PreviousIndexTestRunnable<String> runnable2 = new PreviousIndexTestRunnable<String>(iterator);
	Thread thread2 = this.buildThread(runnable2);
	iterator.slowThread = thread1;

	thread1.start();

	// allow thread 1 to read the first element and get bogged down
	this.sleep(TICK);
	thread2.start();

	// wait for the threads to finish
	thread1.join();
	thread2.join();

	// thread 1 will have the first element,
	// but thread 2 will think the next index is still 0 :-(
	assertEquals("foo", runnable1.previous);
	assertEquals(0, runnable2.previousIndex);
	}

	public void testSynchronizedPreviousIndex() throws Exception {
	TestListIterator<String> nestedIterator = this.buildTestIterator(TWO_TICKS);
	ListIterator<String> iterator = this.buildSynchronizedIterator(nestedIterator);
	iterator.next();

	PreviousTestRunnable<String> runnable1 = new PreviousTestRunnable<String>(iterator);
	Thread thread1 = this.buildThread(runnable1);
	PreviousIndexTestRunnable<String> runnable2 = new PreviousIndexTestRunnable<String>(iterator);
	Thread thread2 = this.buildThread(runnable2);
	nestedIterator.slowThread = thread1;

	thread1.start();

	// allow thread 1 to read the first element and get bogged down
	this.sleep(TICK);
	thread2.start();

	// wait for the threads to finish
	thread1.join();
	thread2.join();

	// thread 1 will have the first element,
	// and thread 2 will think the next index is -1 :-)
	assertEquals("foo", runnable1.previous);
	assertEquals(-1, runnable2.previousIndex);
	}

	public void testUnsynchronizedSet() throws Exception {
	TestListIterator<String> iterator = this.buildTestIterator(TWO_TICKS);
	iterator.next();

	NextTestRunnable<String> runnable1 = new NextTestRunnable<String>(iterator);
	Thread thread1 = this.buildThread(runnable1);
	SetTestRunnable<String> runnable2 = new SetTestRunnable<String>(iterator, "xxx");
	Thread thread2 = this.buildThread(runnable2);
	iterator.slowThread = thread1;

	thread1.start();

	// allow thread 1 to read the first element and get bogged down
	this.sleep(TICK);
	thread2.start();

	// wait for the threads to finish
	thread1.join();
	thread2.join();

	// the wrong element was set :-(
	assertEquals("bar", runnable1.next);
	assertFalse(iterator.list.contains("foo"));
	assertTrue(iterator.list.contains("xxx"));
	assertTrue(iterator.list.contains("bar"));
	assertTrue(iterator.list.contains("baz"));
	}

	public void testSynchronizedSet() throws Exception {
	TestListIterator<String> nestedIterator = this.buildTestIterator(TWO_TICKS);
	ListIterator<String> iterator = this.buildSynchronizedIterator(nestedIterator);
	iterator.next();

	NextTestRunnable<String> runnable1 = new NextTestRunnable<String>(iterator);
	Thread thread1 = this.buildThread(runnable1);
	SetTestRunnable<String> runnable2 = new SetTestRunnable<String>(iterator, "xxx");
	Thread thread2 = this.buildThread(runnable2);
	nestedIterator.slowThread = thread1;

	thread1.start();

	// allow thread 1 to read the first element and get bogged down
	this.sleep(TICK);
	thread2.start();

	// wait for the threads to finish
	thread1.join();
	thread2.join();

	// the right element was set :-)
	assertEquals("bar", runnable1.next);
	assertTrue(nestedIterator.list.contains("foo"));
	assertFalse(nestedIterator.list.contains("bar"));
	assertTrue(nestedIterator.list.contains("xxx"));
	assertTrue(nestedIterator.list.contains("baz"));
	}

	public void testUnsynchronizedAdd() throws Exception {
	TestListIterator<String> iterator = this.buildTestIterator(TWO_TICKS);
	iterator.next();

	NextTestRunnable<String> runnable1 = new NextTestRunnable<String>(iterator);
	Thread thread1 = this.buildThread(runnable1);
	AddTestRunnable<String> runnable2 = new AddTestRunnable<String>(iterator, "xxx");
	Thread thread2 = this.buildThread(runnable2);
	iterator.slowThread = thread1;

	thread1.start();

	// allow thread 1 to read the first element and get bogged down
	this.sleep(TICK);
	thread2.start();

	// wait for the threads to finish
	thread1.join();
	thread2.join();

	// the element was added at the wrong index :-(
	assertEquals("bar", runnable1.next);
	assertTrue(iterator.list.contains("foo"));
	assertEquals(0, iterator.list.indexOf("xxx"));
	assertTrue(iterator.list.contains("xxx"));
	assertTrue(iterator.list.contains("bar"));
	assertTrue(iterator.list.contains("baz"));
	}

	public void testSynchronizedAdd() throws Exception {
	TestListIterator<String> nestedIterator = this.buildTestIterator(TWO_TICKS);
	ListIterator<String> iterator = this.buildSynchronizedIterator(nestedIterator);
	iterator.next();

	NextTestRunnable<String> runnable1 = new NextTestRunnable<String>(iterator);
	Thread thread1 = this.buildThread(runnable1);
	AddTestRunnable<String> runnable2 = new AddTestRunnable<String>(iterator, "xxx");
	Thread thread2 = this.buildThread(runnable2);
	nestedIterator.slowThread = thread1;

	thread1.start();

	// allow thread 1 to read the first element and get bogged down
	this.sleep(TICK);
	thread2.start();

	// wait for the threads to finish
	thread1.join();
	thread2.join();

	// the element was added at the correct index :-)
	assertEquals("bar", runnable1.next);
	assertTrue(nestedIterator.list.contains("foo"));
	assertEquals(1, nestedIterator.list.indexOf("xxx"));
	assertTrue(nestedIterator.list.contains("xxx"));
	assertTrue(nestedIterator.list.contains("bar"));
	assertTrue(nestedIterator.list.contains("baz"));
	}

	@Override
	ListIterator<String> buildSynchronizedIterator(Iterator<String> nestedIterator) {
	return new SynchronizedListIterator<String>((ListIterator<String>) nestedIterator);
	}

	@Override
	TestListIterator<String> buildTestIterator(long delay) {
	return new TestListIterator<String>(delay, this.buildArray());
	}

	/**
	* previous runnable
	*/
	class PreviousTestRunnable<E> implements Runnable {
	final ListIterator<E> iterator;
	E previous;

	PreviousTestRunnable(ListIterator<E> iterator) {
	super();
	this.iterator = iterator;
	}

	public void run() {
	this.previous = this.iterator.previous();
	}

	}

	/**
	* has previous runnable
	*/
	class HasPreviousTestRunnable<E> implements Runnable {
	final ListIterator<E> iterator;
	boolean hasPrevious;

	HasPreviousTestRunnable(ListIterator<E> iterator) {
	super();
	this.iterator = iterator;
	}

	public void run() {
	this.hasPrevious = this.iterator.hasPrevious();
	}

	}

	/**
	* next index runnable
	*/
	class NextIndexTestRunnable<E> implements Runnable {
	final ListIterator<E> iterator;
	int nextIndex;

	NextIndexTestRunnable(ListIterator<E> iterator) {
	super();
	this.iterator = iterator;
	}

	public void run() {
	this.nextIndex = this.iterator.nextIndex();
	}

	}

	/**
	* previous index runnable
	*/
	class PreviousIndexTestRunnable<E> implements Runnable {
	final ListIterator<E> iterator;
	int previousIndex;

	PreviousIndexTestRunnable(ListIterator<E> iterator) {
	super();
	this.iterator = iterator;
	}

	public void run() {
	this.previousIndex = this.iterator.previousIndex();
	}

	}

	/**
	* set runnable
	*/
	class SetTestRunnable<E> implements Runnable {
	final ListIterator<E> iterator;
	final E element;

	SetTestRunnable(ListIterator<E> iterator, E element) {
	super();
	this.iterator = iterator;
	this.element = element;
	}

	public void run() {
	this.iterator.set(this.element);
	}

	}

	/**
	* add runnable
	*/
	class AddTestRunnable<E> implements Runnable {
	final ListIterator<E> iterator;
	final E element;

	AddTestRunnable(ListIterator<E> iterator, E element) {
	super();
	this.iterator = iterator;
	this.element = element;
	}

	public void run() {
	this.iterator.add(this.element);
	}

	}

	/**
	* Test iterator: If {@link #next()} or {@link #previous()} is called
	* while executing on the {@link slowThread}, the iterator will delay
	* for the configured time.
	*/
	static class TestListIterator<E> extends TestIterator<E> implements ListIterator<E> {

	TestListIterator(long delay, E... array) {
	super(delay, array);
	}

	public int nextIndex() {
	return this.nextIndex;
	}

	public boolean hasPrevious() {
	return this.nextIndex != 0;
	}

	public E previous() {
	if (this.hasPrevious()) {
	E previous = this.list.get(this.previousIndex());
	if (Thread.currentThread() == this.slowThread) {
	TestTools.sleep(this.delay);
	}
	this.nextIndex--;
	this.lastIndex = this.nextIndex;
	return previous;
	}
	throw new NoSuchElementException();
	}

	public int previousIndex() {
	return this.nextIndex - 1;
	}

	public void set(E e) {
	if (this.lastIndex == -1) {
	throw new IllegalStateException();
	}
	this.list.set(this.lastIndex, e);
	}

	public void add(E e) {
	this.list.add(this.lastIndex, e);
	this.lastIndex++;
	this.lastIndex = -1;
	}

	}

	}