Attachment #79178 for bug #182059

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




/*******************************************************************************
 * Copyright (c) 2007 Brad Reynolds and others.
 * 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:
 *     Brad Reynolds - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.conformance.databinding;

import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.value.IObservableValue;

/**
 * Abstract implementation of {@link IObservableValueContractDelegate}.
 * 
 * @since 1.1
 */
public abstract class AbstractObservableValueContractDelegate extends
		AbstractObservableContractDelegate implements
		IObservableValueContractDelegate {

	/**
	 * Invokes {@link #createObservableValue(Realm)}.
	 */
	public final IObservable createObservable(Realm realm) {
		return createObservableValue(realm);
	}

	/**
	 * Default implementation returns <code>null</code>.
	 */
	public Object getValueType(IObservableValue observable) {
		// no op
		return null;
	}
	
	/**
	 * Default implementation returns <code>null</code>.
	 */
	public Object createValue(IObservableValue observable) {
		//no op
		return null;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.conformance.databinding;

import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;

/**
 * Tests for IObservableList that don't require mutating the collection.
 * <p>
 * This class is experimental and can change at any time. It is recommended to
 * not subclass or assume the test names will not change. The only API that is
 * guaranteed to not change are the constructors. The tests will remain public
 * and not final in order to allow for consumers to turn off a test if needed by
 * subclassing.
 * </p>
 * 
 * @since 3.2
 */
public class ObservableListContractTest extends
		ObservableCollectionContractTest {
	private IObservableList list;

	private IObservableCollectionContractDelegate delegate;

	/**
	 * @param delegate
	 */
	public ObservableListContractTest(
			IObservableCollectionContractDelegate delegate) {
		super(delegate);
		this.delegate = delegate;
	}

	public ObservableListContractTest(String testName,
			IObservableCollectionContractDelegate delegate) {
		super(testName, delegate);
		this.delegate = delegate;
	}

	protected void setUp() throws Exception {
		super.setUp();

		list = (IObservableList) getObservable();
	}

	public void testListIterator_GetterCalled() throws Exception {
		assertGetterCalled(new Runnable() {
			public void run() {
				list.listIterator();
			}
		}, "List.listIterator()", list);
	}

	public void testGet_GetterCalled() throws Exception {
		list = (IObservableList) delegate.createObservableCollection(new CurrentRealm(true), 1);
		assertGetterCalled(new Runnable() {
			public void run() {
				list.get(0);
			}
		}, "List.get(int)", list);
	}

	public void testIndexOf_GetterCalled() throws Exception {
		assertGetterCalled(new Runnable() {
			public void run() {
				list.indexOf(delegate.createElement(list));
			}
		}, "List.indexOf(int)", list);
	}

	public void testLastIndexOf_GetterCalled() throws Exception {
		assertGetterCalled(new Runnable() {
			public void run() {
				list.lastIndexOf(delegate.createElement(list));
			}
		}, "List.lastIndexOf(Object)", list);
	}

	public void testListIteratorAtIndex_GetterCalled() throws Exception {
		// Create a new list instead of adding an item because the list might
		// not be mutable
		list = (IObservableList) delegate.createObservableCollection(new CurrentRealm(true), 1);
		assertGetterCalled(new Runnable() {
			public void run() {
				list.listIterator(0);
			}
		}, "List.listIterator(int)", list);
	}

	public void testSubList_GetterCalled() throws Exception {
		list = (IObservableList) delegate.createObservableCollection(new CurrentRealm(true), 1);
		assertGetterCalled(new Runnable() {
			public void run() {
				list.subList(0, 1);
			}
		}, "List.subList(int, int)", list);
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.conformance.databinding;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.list.ListDiffEntry;
import org.eclipse.jface.tests.databinding.EventTrackers.ChangeEventTracker;
import org.eclipse.jface.tests.databinding.EventTrackers.ListChangeEventTracker;

/**
 * Mutability tests for IObservableList.
 * 
 * <p>
 * This class is experimental and can change at any time. It is recommended to
 * not subclass or assume the test names will not change. The only API that is
 * guaranteed to not change are the constructors. The tests will remain public
 * and not final in order to allow for consumers to turn off a test if needed by
 * subclassing.
 * </p>
 * 
 * @since 3.2
 */
public class MutableObservableListContractTest extends
		MutableObservableCollectionContractTest {
	private IObservableCollectionContractDelegate delegate;

	private IObservableList list;

	/**
	 * @param delegate
	 */
	public MutableObservableListContractTest(
			IObservableCollectionContractDelegate delegate) {
		super(delegate);
		this.delegate = delegate;
	}

	public MutableObservableListContractTest(String testName,
			IObservableCollectionContractDelegate delegate) {
		super(testName, delegate);
		this.delegate = delegate;
	}

	protected void setUp() throws Exception {
		super.setUp();
		list = (IObservableList) getObservable();
	}

	public void testAdd_ListChangeEvent() throws Exception {
		assertListChangeEventFired(new Runnable() {
			public void run() {
				list.add(delegate.createElement(list));
			}
		}, "List.add(Object)", list);
	}

	public void testAdd_ListDiffEntry() throws Exception {
		list.add(delegate.createElement(list));
		final Object element = delegate.createElement(list);

		assertAddDiffEntry(new Runnable() {
			public void run() {
				list.add(element);
			}
		}, "List.add(Object)", list, element, 1);
	}

	public void testAddAtIndex_ChangeEvent() throws Exception {
		assertChangeEventFired(new Runnable() {
			public void run() {
				list.add(0, delegate.createElement(list));
			}
		}, "List.add(int, Object)", list);
	}

	public void testAddAtIndex_ListChangeEvent() throws Exception {
		assertListChangeEventFired(new Runnable() {
			public void run() {
				list.add(0, delegate.createElement(list));
			}
		}, "List.add(int, Object)", list);
	}

	public void testAddAtIndex_ChangeEventFiredAfterElementIsAdded()
			throws Exception {
		final Object element = delegate.createElement(list);

		assertContainsDuringChangeEvent(new Runnable() {
			public void run() {
				list.add(0, element);
			}
		}, "List.add(int, Collection)", list, element);
	}

	public void testAddAtIndex_ListDiffEntry() throws Exception {
		list.add(delegate.createElement(list));
		final Object element = delegate.createElement(list);

		assertAddDiffEntry(new Runnable() {
			public void run() {
				list.add(1, element);
			}
		}, "List.add(int, Object)", list, element, 1);
	}

	public void testAddAll_ListChangeEvent() throws Exception {
		assertListChangeEventFired(new Runnable() {
			public void run() {
				list.addAll(Arrays.asList(new Object[] { delegate
						.createElement(list) }));
			}
		}, "List.addAll(Collection", list);
	}

	public void testAddAll_ListDiffEntry() throws Exception {
		final Object element = delegate.createElement(list);

		assertAddDiffEntry(new Runnable() {
			public void run() {
				list.addAll(Arrays.asList(new Object[] { element }));
			}
		}, "List.addAll(Collection)", list, element, 0);
	}

	public void testAddAllAtIndex_ChangeEvent() throws Exception {
		assertChangeEventFired(new Runnable() {
			public void run() {
				list.addAll(0, Arrays.asList(new Object[] { delegate
						.createElement(list) }));
			}
		}, "List.addAll(int, Collection)", list);
	}

	public void testAddAllAtIndex_ListChangeEvent() throws Exception {
		assertListChangeEventFired(new Runnable() {
			public void run() {
				list.addAll(0, Arrays.asList(new Object[] { delegate
						.createElement(list) }));
			}
		}, "List.addAll(int, Collection)", list);
	}

	public void testAddAllAtIndex_ChangeEventFiredAfterElementIsAdded()
			throws Exception {
		final Object element = delegate.createElement(list);

		assertContainsDuringChangeEvent(new Runnable() {
			public void run() {
				list.addAll(0, Arrays.asList(new Object[] { element }));
			}
		}, "List.addAll(int, Collection)", list, element);
	}

	public void testAddAllAtIndex_ListDiffEntry() throws Exception {
		list.add(delegate.createElement(list));
		final Object element = delegate.createElement(list);

		assertAddDiffEntry(new Runnable() {
			public void run() {
				list.addAll(1, Arrays.asList(new Object[] { element }));
			}
		}, "List.addAll(int, Collection)", list, element, 1);
	}

	public void testSet_ChangeEvent() throws Exception {
		list.add(delegate.createElement(list));

		assertChangeEventFired(new Runnable() {
			public void run() {
				list.set(0, delegate.createElement(list));
			}
		}, "List.set(int, Object)", list);
	}

	public void testSet_ListChangeEvent() throws Exception {
		list.add(delegate.createElement(list));

		assertListChangeEventFired(new Runnable() {
			public void run() {
				list.set(0, delegate.createElement(list));
			}
		}, "List.set(int, Object)", list);
	}

	public void testSet_ChangeEventFiredAfterElementIsSet() throws Exception {
		Object element1 = delegate.createElement(list);
		list.add(element1);
		final Object element2 = delegate.createElement(list);

		assertContainsDuringChangeEvent(new Runnable() {
			public void run() {
				list.set(0, element2);
			}
		}, "List.set(int, Object)", list, element2);
	}

	public void testSet_ListDiffEntry() throws Exception {
		list.add(delegate.createElement(list));
		Object oldElement = delegate.createElement(list);
		list.add(oldElement);

		ListChangeEventTracker listener = new ListChangeEventTracker();
		list.addListChangeListener(listener);

		Object newElement = delegate.createElement(list);
		list.set(1, newElement);

		ListDiffEntry[] entries = listener.event.diff.getDifferences();
		assertEquals(
				"List.set(int, Object) should result in 2 list diff entries.",
				2, entries.length);

		ListDiffEntry add = null;
		ListDiffEntry remove = null;

		if (entries[0].isAddition() && !entries[1].isAddition()) {
			add = entries[0];
			remove = entries[1];
		} else if (!entries[0].isAddition() && entries[1].isAddition()) {
			add = entries[1];
			remove = entries[0];
		} else {
			fail("List.set(int, Object) should result in an add and a remove entry.");
		}

		assertEquals(
				"List.set(int, Object) removed element should be the old element.",
				oldElement, remove.getElement());
		assertEquals(
				"List.set(int, Object) removed index should be the index the new element was set at.",
				1, remove.getPosition());

		assertEquals(
				"List.set(int, Object) added element should be the set element.",
				newElement, add.getElement());
		assertEquals(
				"List.set(int, Object) add index should be the index the new element was set at.",
				1, add.getPosition());
	}

	public void testRemove_ListChangeEvent() throws Exception {
		final Object element = delegate.createElement(list);
		list.add(element);

		assertListChangeEventFired(new Runnable() {
			public void run() {
				list.remove(element);
			}
		}, "List.remove(Object)", list);
	}

	public void testRemove_ListDiffEntry() throws Exception {
		list.add(delegate.createElement(list));
		final Object element = delegate.createElement(list);
		list.add(element);

		assertRemoveDiffEntry(new Runnable() {
			public void run() {
				list.remove(element);
			}
		}, "List.remove(Object)", list, element, 1);
	}

	public void testRemoveAtIndex_ChangeEvent() throws Exception {
		list.add(delegate.createElement(list));

		assertChangeEventFired(new Runnable() {
			public void run() {
				list.remove(0);
			}
		}, "List.remove(int)", list);
	}

	public void testRemoveAtIndex_ListChangeEvent() throws Exception {
		list.add(delegate.createElement(list));

		assertListChangeEventFired(new Runnable() {
			public void run() {
				list.remove(0);
			}
		}, "List.remove(int)", list);
	}

	public void testRemoveAtIndex_ChangeEventFiredAfterElementIsRemoved()
			throws Exception {
		final Object element = delegate.createElement(list);
		list.add(element);

		assertDoesNotContainDuringChangeEvent(new Runnable() {
			public void run() {
				list.remove(0);
			}
		}, "List.remove(int)", list, element);
	}

	public void testRemoveAtIndex_ListDiffEntry() throws Exception {
		list.add(delegate.createElement(list));
		Object element = delegate.createElement(list);
		list.add(element);

		assertRemoveDiffEntry(new Runnable() {
			public void run() {
				list.remove(1);
			}
		}, "List.remove(int)", list, element, 1);
	}

	public void testRemoveAll_ListChangeEvent() throws Exception {
		final Object element = delegate.createElement(list);

		assertListChangeEventFired(new Runnable() {
			public void run() {
				list.removeAll(Arrays.asList(new Object[] { element }));
			}
		}, "List.removeAll(Collection)", list);
	}

	public void testRemoveAll_ListDiffEntry() throws Exception {
		final Object element = delegate.createElement(list);
		list.add(element);

		assertRemoveDiffEntry(new Runnable() {
			public void run() {
				list.removeAll(Arrays.asList(new Object[] { element }));
			}
		}, "List.removeAll(Collection)", list, element, 0);
	}

	public void testRetainAll_ListChangeEvent() throws Exception {
		final Object element1 = delegate.createElement(list);
		list.add(element1);
		list.add(delegate.createElement(list));

		assertListChangeEventFired(new Runnable() {
			public void run() {
				list.retainAll(Arrays.asList(new Object[] { element1 }));
			}
		}, "List.retainAll(Collection", list);
	}

	public void testRetainAll_ListDiffEntry() throws Exception {
		final Object element1 = delegate.createElement(list);
		list.add(element1);
		Object element2 = delegate.createElement(list);
		list.add(delegate.createElement(list));

		assertRemoveDiffEntry(new Runnable() {
			public void run() {
				list.retainAll(Arrays.asList(new Object[] { element1 }));
			}
		}, "List.retainAll(Collection)", list, element2, 1);
	}

	public void testClear_ListChangeEvent() throws Exception {
		list.add(delegate.createElement(list));

		assertListChangeEventFired(new Runnable() {
			public void run() {
				list.clear();
			}
		}, "List.clear()", list);
	}

	public void testClear_ListDiffEntry() throws Exception {
		Object element = delegate.createElement(list);
		list.add(element);

		assertRemoveDiffEntry(new Runnable() {
			public void run() {
				list.clear();
			}
		}, "List.clear()", list, element, 0);
	}

	/**
	 * Asserts standard behaviors of firing list change events.
	 * <ul>
	 * <li>Event fires once.</li>
	 * <li>Source of the event is the provided <code>list</code>.
	 * <li>The list change event is fired after the change event.</li>
	 * </ul>
	 * 
	 * @param runnable
	 * @param methodName
	 * @param list
	 */
	private void assertListChangeEventFired(Runnable runnable,
			String methodName, IObservableList list) {
		List queue = new ArrayList();
		ListChangeEventTracker listListener = new ListChangeEventTracker(queue);
		ChangeEventTracker changeListener = new ChangeEventTracker(queue);

		list.addListChangeListener(listListener);
		list.addChangeListener(changeListener);

		runnable.run();

		assertEquals(formatFail(methodName + " should fire one ListChangeEvent."), 1,
				listListener.count);
		assertEquals(formatFail(methodName
				+ "'s change event observable should be the created List."),
				list, listListener.event.getObservable());

		assertEquals(formatFail("Two notifications should have been received."), 2, queue
				.size());
		assertEquals("ChangeEvent of " + methodName
				+ " should have fired before the ListChangeEvent.",
				changeListener, queue.get(0));
		assertEquals("ListChangeEvent of " + methodName
				+ " should have fired after the ChangeEvent.", listListener,
				queue.get(1));
	}

	/**
	 * Asserts the list diff entry for a remove operation.
	 * 
	 * @param runnable
	 * @param methodName
	 * @param list
	 * @param element
	 * @param index
	 */
	private void assertRemoveDiffEntry(Runnable runnable, String methodName,
			IObservableList list, Object element, int index) {
		ListChangeEventTracker listener = new ListChangeEventTracker();
		list.addListChangeListener(listener);

		runnable.run();

		ListDiffEntry[] entries = listener.event.diff.getDifferences();
		assertEquals(methodName + " should result in one diff entry.", 1,
				entries.length);

		ListDiffEntry entry = entries[0];
		assertFalse(methodName
				+ " should result in a diff entry that is an removal.", entry
				.isAddition());
		assertEquals(methodName
				+ " remove diff entry should have removed the element.",
				element, entry.getElement());
		assertEquals(
				methodName
						+ " remove diff entry should have removed the element from the provided index.",
				index, entry.getPosition());
	}

	/**
	 * Asserts the list diff entry for an add operation.
	 * 
	 * @param runnable
	 * @param methodName
	 * @param list
	 * @param element
	 * @param index
	 */
	private void assertAddDiffEntry(Runnable runnable, String methodName,
			IObservableList list, Object element, int index) {
		ListChangeEventTracker listener = new ListChangeEventTracker();
		list.addListChangeListener(listener);

		runnable.run();

		ListDiffEntry[] entries = listener.event.diff.getDifferences();
		assertEquals(methodName + " should result in one diff entry.", 1,
				entries.length);

		ListDiffEntry entry = entries[0];
		assertTrue(methodName
				+ " should result in a diff entry that is an addition.", entry
				.isAddition());
		assertEquals(methodName
				+ " add diff entry should have added the element.", element,
				entry.getElement());
		assertEquals(
				methodName
						+ "add diff entry should have added the element at the provided index.",
				index, entry.getPosition());
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.conformance.databinding;

import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.jface.tests.databinding.RealmTester;
import org.eclipse.jface.tests.databinding.EventTrackers.ChangeEventTracker;
import org.eclipse.jface.tests.databinding.EventTrackers.ValueChangeEventTracker;
import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;

/**
 * Mutability tests for IObservableValue.
 * 
 * <p>
 * This class is experimental and can change at any time. It is recommended to
 * not subclass or assume the test names will not change. The only API that is
 * guaranteed to not change are the constructors. The tests will remain public
 * and not final in order to allow for consumers to turn off a test if needed by
 * subclassing.
 * </p>
 * 
 * @since 3.2
 */
public class MutableObservableValueContractTest extends
		ObservableDelegateTest {
	private IObservableValueContractDelegate delegate;

	private IObservableValue observable;

	/**
	 * @param delegate
	 */
	public MutableObservableValueContractTest(
			IObservableValueContractDelegate delegate) {
		this(null, delegate);
	}

	public MutableObservableValueContractTest(String testName,
			IObservableValueContractDelegate delegate) {
		super(testName, delegate);
		this.delegate = delegate;
	}

	protected void setUp() throws Exception {
		super.setUp();

		this.observable = (IObservableValue) getObservable();
	}

	public void testSetValue_SetsValue() throws Exception {
		Object value = delegate.createValue(observable);
		
		observable.setValue(value);
		assertEquals(formatFail("IObservableValue.setValue(Object) should set the value of the observable."), value, observable.getValue());
	}
	
	public void testSetValue_ChangeEvent() throws Exception {
		ChangeEventTracker listener = new ChangeEventTracker().register(observable);
		
		observable.setValue(delegate.createValue(observable));
		
		assertEquals(formatFail("Change event listeners were not notified"), 1, listener.count);
		assertEquals(formatFail("IObservableValue.setValue(Object) should fire one ChangeEvent."), 1,
				listener.count);
		assertEquals(
				formatFail("IObservableValue.setValue(Object)'s change event observable should be the created observable."),
				observable, listener.event.getObservable());
	}
	
	public void testSetValue_SameValue() throws Exception {
		// invoke change to ensure observable has a value
		delegate.change(observable);

		ValueChangeEventTracker valueChangeListener = new ValueChangeEventTracker()
				.register(observable);
		ChangeEventTracker changeListener = new ChangeEventTracker().register(observable);
		Object value = observable.getValue();
		observable.setValue(value);

		assertEquals(
				formatFail("IObservableValue.setValue() should not fire a value change event when the value has not change."),
				0, valueChangeListener.count);
		assertEquals(
				formatFail("IObservableValue.setValue() should not fire a change event when the value has not change."),
				0, changeListener.count);
	}
	
	public void testSetValue_RealmChecks() throws Exception {
		RealmTester.exerciseCurrent(new Runnable() {
			public void run() {
				observable.setValue(delegate.createValue(observable));
			}
		}, (CurrentRealm) observable.getRealm());
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Brad Reynolds and others.
 * 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:
 *     Brad Reynolds - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.conformance.databinding;

import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.value.IObservableValue;

/**
 * Delegate interface for an observable value.
 * 
 * <p>
 * This interface is not intended to be implemented by clients. Clients should
 * instead subclass one of the classes that implement this interface. Note that
 * direct implementers of this interface outside of the framework will be broken
 * in future releases when methods are added to this interface.
 * </p>
 * 
 * @since 1.1
 */
public interface IObservableValueContractDelegate extends
		IObservableContractDelegate {

	/**
	 * Creates a new observable value.
	 * 
	 * @param realm
	 *            realm of the observable
	 * @return observable value
	 */
	public IObservableValue createObservableValue(Realm realm);

	/**
	 * Returns the expected type of the observable.
	 * 
	 * @param observable
	 * @return type
	 */
	public Object getValueType(IObservableValue observable);
	
	/**
	 * Returns a valid value that is not the current value of the observable.
	 * 
	 * @param observable
	 * @return value
	 */
	public Object createValue(IObservableValue observable);
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.conformance.databinding;

import junit.framework.TestCase;

import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.jface.tests.databinding.RealmTester;
import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;

/**
 * TestCase that provides the standard behavior expected for delegating test cases.
 * 
 * @since 3.2
 */
public class ObservableDelegateTest extends TestCase {
	private IObservableContractDelegate delegate;

	private Realm previousRealm;

	private IObservable observable;
	private String debugInfo;

	public ObservableDelegateTest(IObservableContractDelegate delegate) {
		this(null, delegate);
	}
	
	public ObservableDelegateTest(String testName, IObservableContractDelegate delegate) {
		super(testName);
		this.delegate = delegate;
	}

	protected void setUp() throws Exception {
		super.setUp();
		previousRealm = Realm.getDefault();

		delegate.setUp();
		observable = doCreateObservable();
	}

	protected void tearDown() throws Exception {
		super.tearDown();

		delegate.tearDown();
		observable.dispose();
		observable = null;
		
		RealmTester.setDefault(previousRealm);

		observable = null;
		previousRealm = null;
	}
	
	/**
	 * Creates a new observable with a default realm. Invoked from
	 * {@link #setUp()}. Override to customize the creation of observables
	 * (e.g. specifying a different Realm).
	 * 
	 * @return observable
	 */
	protected IObservable doCreateObservable() {
		return delegate.createObservable(new CurrentRealm(true));
	}

	/**
	 * Returns the created observable. The observable is created in
	 * {@link #setUp()}. If invoked before {@link #setUp()} will be
	 * <code>null</code>.
	 * 
	 * @return observable
	 */
	protected IObservable getObservable() {
		return observable;
	}	
	
	/**
	 * Returns the delegate in use.
	 * 
	 * @return delegate
	 */
	protected IObservableContractDelegate getObservableContractDelegate() {
		return delegate;
	}
	
	protected String formatFail(String message) {
		return message + getDebugString();
	}
	
	private String getDebugString() {
		if (debugInfo == null) {
			debugInfo = "(Test: " + this.getClass().getName() + ", Delegate: " + delegate.getClass().getName() + ")";
		}
		
		return debugInfo;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Brad Reynolds and others.
 * 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:
 *     Brad Reynolds - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.conformance.databinding;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.databinding.observable.ChangeEvent;
import org.eclipse.core.databinding.observable.IChangeListener;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.observable.value.IValueChangeListener;
import org.eclipse.core.databinding.observable.value.ValueChangeEvent;
import org.eclipse.jface.tests.databinding.RealmTester;
import org.eclipse.jface.tests.databinding.EventTrackers.ValueChangeEventTracker;
import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;

/**
 * @since 3.2
 */
public class ObservableValueContractTest extends ObservableContractTest {
	private IObservableValueContractDelegate delegate;
	private IObservableValue observable;

	public ObservableValueContractTest(IObservableValueContractDelegate delegate) {
		super(delegate);
		this.delegate = delegate;			
	}

	/**
	 * @param testName
	 * @param delegate
	 */
	public ObservableValueContractTest(String testName,
			IObservableValueContractDelegate delegate) {
		super(testName, delegate);
		this.delegate = delegate;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.conformance.databinding.ObservableContractTest#setUp()
	 */
	protected void setUp() throws Exception {
		super.setUp();
		observable = (IObservableValue) getObservable();
	}

	public void testChange_ValueChangeEvent() throws Exception {
		ValueChangeEventTracker listener = new ValueChangeEventTracker().register(observable);

		delegate.change(observable);
		assertEquals(formatFail("On change value change listeners should be notified."), 1,
				listener.count);
	}

	public void testGetValueType_ExpectedType() throws Exception {
		assertEquals(formatFail("Type of the value should be returned from getType()."),
				delegate.getValueType(observable), observable.getValueType());
	}

	public void testChange_OrderOfNotifications() throws Exception {
		final List listeners = new ArrayList();
		IChangeListener changeListener = new IChangeListener() {
			public void handleChange(ChangeEvent event) {
				listeners.add(this);
			}
		};

		IValueChangeListener valueChangeListener = new IValueChangeListener() {
			public void handleValueChange(ValueChangeEvent event) {
				listeners.add(this);
			}
		};

		observable.addChangeListener(changeListener);
		observable.addValueChangeListener(valueChangeListener);

		delegate.change(observable);
		
		assertTrue(formatFail("Change Listeners were not notified on change."), listeners.size() > 0);
		
		// not asserting the fact that both are notified as this is asserted in
		// other tests
		assertEquals(
				formatFail("Change listeners should be notified before value change listeners."),
				changeListener, listeners.get(0));
		assertEquals(
				formatFail("Value change listeners should be notified after change listeners."),
				valueChangeListener, listeners.get(1));
	}

	public void testChange_ValueChangeEventDiff() throws Exception {
		ValueChangeEventTracker listener = new ValueChangeEventTracker().register(observable);
		Object oldValue = observable.getValue();

		delegate.change(observable);

		ValueChangeEvent event = listener.event;
		
		assertTrue(formatFail("Change Listeners were not notified on change."), listener.count > 0);
		
		assertEquals(
				formatFail("When a value change event is fired the old value should be the previous value of the observable value."),
				oldValue, event.diff.getOldValue());
		assertEquals(
				formatFail("When a value change event is fired the new value should be the same as the current value of the observable value."),
				observable.getValue(), event.diff.getNewValue());
	}

	public void testChange_ValueChangeEventFiredAfterValueIsSet()
			throws Exception {
		class ValueChangeListener extends ValueChangeEventTracker {
			Object value;

			public void handleValueChange(ValueChangeEvent event) {
				super.handleValueChange(event);

				this.value = event.getObservableValue().getValue();
			}
		}

		ValueChangeListener listener = (ValueChangeListener) new ValueChangeListener()
				.register(observable);
		delegate.change(observable);
		assertEquals(
				formatFail("When a value change event is fired the new value should be applied before firing the change event."),
				listener.value, observable.getValue());
	}

	public void testRemoveValueChangeListener_RemovesListener() throws Exception {
		ValueChangeEventTracker listener = new ValueChangeEventTracker().register(observable);
		delegate.change(observable);

		// precondition
		assertEquals(formatFail("Value change listeners should be notified on change."), 1,
				listener.count);

		observable.removeValueChangeListener(listener);
		delegate.change(observable);

		assertEquals(
				formatFail("Value change listeners should not be notified after they've been removed from the observable."),
				1, listener.count);
	}

	public void testGetValue_GetterCalled() throws Exception {
		assertGetterCalled(new Runnable() {
			public void run() {
				observable.getValue();
			}
		}, formatFail("IObservableValue.getValue()"), observable);
	}

	public void testGetValue_RealmCheck() throws Exception {
		RealmTester.exerciseCurrent(new Runnable() {
			public void run() {
				observable.getValue();
			}
		}, (CurrentRealm) observable.getRealm());
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Brad Reynolds and others.
 * 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:
 *     Brad Reynolds - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.conformance.databinding;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;

import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.jface.tests.databinding.EventTrackers.ChangeEventTracker;
import org.eclipse.jface.tests.databinding.EventTrackers.SetChangeEventTracker;

/**
 */
public class MutableObservableSetContractTest extends
		MutableObservableCollectionContractTest {
	private IObservableCollectionContractDelegate delegate;

	private IObservableSet set;

	public MutableObservableSetContractTest(String testName,
			IObservableCollectionContractDelegate delegate) {
		super(testName, delegate);
		this.delegate = delegate;
	}

	/**
	 * @param delegate
	 */
	public MutableObservableSetContractTest(
			IObservableCollectionContractDelegate delegate) {
		super(delegate);
	}

	protected void setUp() throws Exception {
		super.setUp();
		set = (IObservableSet) getObservable();
	}

	public void testAdd_SetChangeEvent() throws Exception {
		assertSetChangeEventFired(new Runnable() {
			public void run() {
				set.add(delegate.createElement(set));
			}
		}, "Set.add(Object)", set);
	}

	public void testAdd_SetDiffEntry() throws Exception {
		set.add(delegate.createElement(set));
		final Object element = delegate.createElement(set);

		assertAddDiffEntry(new Runnable() {
			public void run() {
				set.add(element);
			}
		}, "Set.add(Object)", set, element);
	}

	public void testAddAll_SetChangeEvent() throws Exception {
		assertSetChangeEventFired(new Runnable() {
			public void run() {
				set.addAll(Arrays.asList(new Object[] { delegate
						.createElement(set) }));
			}
		}, "Set.addAll(Collection", set);
	}

	public void testAddAll_SetDiffEntry() throws Exception {
		final Object element = delegate.createElement(set);

		assertAddDiffEntry(new Runnable() {
			public void run() {
				set.addAll(Arrays.asList(new Object[] { element }));
			}
		}, "Set.addAll(Collection)", set, element);
	}

	public void testRemove_SetChangeEvent() throws Exception {
		final Object element = delegate.createElement(set);
		set.add(element);

		assertSetChangeEventFired(new Runnable() {
			public void run() {
				set.remove(element);
			}
		}, "Set.remove(Object)", set);
	}

	public void testRemove_SetDiffEntry() throws Exception {
		set.add(delegate.createElement(set));
		final Object element = delegate.createElement(set);
		set.add(element);

		assertRemoveDiffEntry(new Runnable() {
			public void run() {
				set.remove(element);
			}
		}, "Set.remove(Object)", set, element);
	}

	public void testRemoveAll_SetChangeEvent() throws Exception {
		final Object element = delegate.createElement(set);
		set.add(element);

		assertSetChangeEventFired(new Runnable() {
			public void run() {
				set.removeAll(Arrays.asList(new Object[] { element }));
			}
		}, "Set.removeAll(Collection)", set);
	}

	public void testRemoveAll_SetDiffEntry() throws Exception {
		final Object element = delegate.createElement(set);
		set.add(element);

		assertRemoveDiffEntry(new Runnable() {
			public void run() {
				set.removeAll(Arrays.asList(new Object[] { element }));
			}
		}, "Set.removeAll(Collection)", set, element);
	}

	public void testRetainAll_SetChangeEvent() throws Exception {
		final Object element1 = delegate.createElement(set);
		set.add(element1);
		set.add(delegate.createElement(set));

		assertSetChangeEventFired(new Runnable() {
			public void run() {
				set.retainAll(Arrays.asList(new Object[] { element1 }));
			}
		}, "Set.retainAll(Collection", set);
	}

	public void testRetainAll_SetDiffEntry() throws Exception {
		final Object element1 = delegate.createElement(set);
		set.add(element1);
		Object element2 = delegate.createElement(set);
		set.add(delegate.createElement(set));

		assertRemoveDiffEntry(new Runnable() {
			public void run() {
				set.retainAll(Arrays.asList(new Object[] { element1 }));
			}
		}, "Set.retainAll(Collection)", set, element2);
	}

	public void testClear_SetChangeEvent() throws Exception {
		set.add(delegate.createElement(set));

		assertSetChangeEventFired(new Runnable() {
			public void run() {
				set.clear();
			}
		}, "Set.clear()", set);
	}

	public void testClear_SetDiffEntry() throws Exception {
		Object element = delegate.createElement(set);
		set.add(element);

		assertRemoveDiffEntry(new Runnable() {
			public void run() {
				set.clear();
			}
		}, "Set.clear()", set, element);
	}

	/**
	 * Asserts standard behaviors of firing set change events.
	 * <ul>
	 * <li>Event fires once.</li>
	 * <li>Source of the event is the provided <code>set</code>.
	 * <li>The set change event is fired after the change event.</li>
	 * </ul>
	 * 
	 * @param runnable
	 * @param methodName
	 * @param set
	 */
	private void assertSetChangeEventFired(Runnable runnable,
			String methodName, IObservableSet set) {
		List queue = new ArrayList();
		SetChangeEventTracker setListener = new SetChangeEventTracker(queue);
		ChangeEventTracker changeListener = new ChangeEventTracker(queue);

		set.addSetChangeListener(setListener);
		set.addChangeListener(changeListener);

		runnable.run();

		assertEquals(formatFail(methodName + " should fire one SetChangeEvent."), 1,
				setListener.count);
		assertEquals(formatFail(methodName
				+ "'s change event observable should be the created Set."), set,
				setListener.event.getObservable());

		assertEquals(formatFail("Two notifications should have been received."), 2, queue
				.size());
		assertEquals(formatFail("ChangeEvent of " + methodName
				+ " should have fired before the SetChangeEvent."),
				changeListener, queue.get(0));
		assertEquals(formatFail("SetChangeEvent of " + methodName
				+ " should have fired after the ChangeEvent."), setListener,
				queue.get(1));
	}

	/**
	 * Asserts the set diff entry for an add operation.
	 * 
	 * @param runnable
	 * @param methodName
	 * @param set
	 * @param element
	 */
	private void assertAddDiffEntry(Runnable runnable, String methodName,
			IObservableSet set, Object element) {
		SetChangeEventTracker listener = new SetChangeEventTracker();
		set.addSetChangeListener(listener);

		runnable.run();

		Set entries = listener.event.diff.getAdditions();
		assertEquals(formatFail(methodName + " should result in one diff entry."), 1,
				entries.size());

		assertTrue(formatFail(methodName
				+ " should result in a diff entry that is an addition."),
				entries.contains(element));
	}

	/**
	 * Asserts the set diff entry for a remove operation.
	 * 
	 * @param runnable
	 * @param methodName
	 * @param set
	 * @param element
	 */
	private void assertRemoveDiffEntry(Runnable runnable, String methodName,
			IObservableSet set, Object element) {
		SetChangeEventTracker listener = new SetChangeEventTracker();
		set.addSetChangeListener(listener);

		runnable.run();

		Set entries = listener.event.diff.getRemovals();
		assertEquals(formatFail(methodName + " should result in one diff entry."), 1,
				entries.size());

		assertTrue(formatFail(methodName
				+ " should result in a diff entry that is an addition."),
				entries.contains(element));
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.conformance.databinding;

import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.jface.databinding.swt.SWTObservables;
import org.eclipse.jface.tests.databinding.RealmTester.DelegatingRealm;
import org.eclipse.swt.widgets.Display;

/**
 * Mutability tests for IObservableValue for a SWT widget.
 * 
 * <p>
 * This class is experimental and can change at any time. It is recommended to
 * not subclass or assume the test names will not change. The only API that is
 * guaranteed to not change are the constructors. The tests will remain public
 * and not final in order to allow for consumers to turn off a test if needed by
 * subclassing.
 * </p>
 * 
 * @since 3.2
 */
public class SWTMutableObservableValueContractTest extends
		MutableObservableValueContractTest {
	private IObservableValueContractDelegate delegate;

	public SWTMutableObservableValueContractTest(
			IObservableValueContractDelegate delegate) {
		this(null, delegate);
	}

	/**
	 * @param testName
	 * @param delegate
	 */
	public SWTMutableObservableValueContractTest(String testName,
			IObservableValueContractDelegate delegate) {
		super(testName, delegate);
		this.delegate = delegate;
	}

	/**
	 * Creates a new observable passing the realm for the current display.
	 */
	protected IObservable doCreateObservable() {
		Display display = Display.getCurrent();
		if (display == null) {
			display = new Display();
		}
		DelegatingRealm delegateRealm = new DelegatingRealm(SWTObservables
				.getRealm(display));
		delegateRealm.setCurrent(true);

		return delegate.createObservable(delegateRealm);
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.conformance.databinding;

import java.util.Arrays;

import org.eclipse.core.databinding.observable.IObservableCollection;
import org.eclipse.jface.tests.databinding.RealmTester;
import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;

/**
 * Tests for IObservableCollection that don't mutate the collection.
 * <p>
 * This class is experimental and can change at any time. It is recommended to
 * not subclass or assume the test names will not change. The only API that is
 * guaranteed to not change are the constructors. The tests will remain public
 * and not final in order to allow for consumers to turn off a test if needed by
 * subclassing.
 * </p>
 * 
 * @since 3.2
 */
public class ObservableCollectionContractTest extends ObservableContractTest {
	private IObservableCollectionContractDelegate delegate;

	private IObservableCollection collection;

	public ObservableCollectionContractTest(
			IObservableCollectionContractDelegate delegate) {
		super(delegate);
		this.delegate = delegate;
	}

	public ObservableCollectionContractTest(String testName,
			IObservableCollectionContractDelegate delegate) {
		super(testName, delegate);
		this.delegate = delegate;
	}

	protected void setUp() throws Exception {
		super.setUp();
		
		collection = (IObservableCollection) getObservable();
	}

	public void testIterator_GetterCalled() throws Exception {
		assertGetterCalled(new Runnable() {
			public void run() {
				collection.iterator();
			}
		}, "Collection.iterator()", collection);
	}
	
	public void testIterator_RealmCheck() throws Exception {
		RealmTester.exerciseCurrent(new Runnable() {
			public void run() {
				collection.iterator();
			}
		}, (CurrentRealm) collection.getRealm());
	}

	public void testSize_GetterCalled() throws Exception {
		assertGetterCalled(new Runnable() {
			public void run() {
				collection.size();
			}
		}, "Collection.size()", collection);
	}
	
	public void testSize_RealmCheck() throws Exception {
		RealmTester.exerciseCurrent(new Runnable() {
			public void run() {
				collection.size();
			}
		}, (CurrentRealm) collection.getRealm());
	}

	public void testIsEmpty_GetterCalled() throws Exception {
		assertGetterCalled(new Runnable() {
			public void run() {
				collection.isEmpty();
			}
		}, "Collection.isEmpty()", collection);
	}
	
	public void testIsEmpty_RealmCheck() throws Exception {
		RealmTester.exerciseCurrent(new Runnable() {
			public void run() {
				collection.isEmpty();
			}
		}, (CurrentRealm) collection.getRealm());
	}

	public void testContains_GetterCalled() throws Exception {
		assertGetterCalled(new Runnable() {
			public void run() {
				collection.contains(delegate.createElement(collection));
			}
		}, "Collection.contains(...)", collection);
	}
	
	public void testContains_RealmCheck() throws Exception {
		RealmTester.exerciseCurrent(new Runnable() {
			public void run() {
				collection.contains(delegate.createElement(collection));
			}
		}, (CurrentRealm) collection.getRealm());
	}

	public void testContainsAll_GetterCalled() throws Exception {
		assertGetterCalled(new Runnable() {
			public void run() {
				collection.containsAll(Arrays.asList(new Object[] { delegate
						.createElement(collection) }));
			}
		}, "Collection.containsAll(Collection)", collection);
	}

	public void testContainsAll_RealmCheck() throws Exception {
		RealmTester.exerciseCurrent(new Runnable() {
			public void run() {
				collection.containsAll(Arrays.asList(new Object[] { delegate
						.createElement(collection) }));
			}
		}, (CurrentRealm) collection.getRealm());
	}
	
	public void testToArray_GetterCalled() throws Exception {
		assertGetterCalled(new Runnable() {
			public void run() {
				collection.toArray();
			}
		}, "Collection.toArray()", collection);
	}
	
	public void testToArray_RealmCheck() throws Exception {
		RealmTester.exerciseCurrent(new Runnable() {
			public void run() {
				collection.toArray();
			}
		}, (CurrentRealm) collection.getRealm());
	}

	public void testToArrayWithObjectArray_GetterCalled() throws Exception {
		assertGetterCalled(new Runnable() {
			public void run() {
				collection.toArray(new Object[collection.size()]);
			}
		}, "Collection.toArray(Object[])", collection);
	}
	
	public void testToArrayWithObjectArray_RealmCheck() throws Exception {
		RealmTester.exerciseCurrent(new Runnable() {
			public void run() {
				collection.toArray(new Object[collection.size()]);
			}
		}, (CurrentRealm) collection.getRealm());
	}

	public void testEquals_GetterCalled() throws Exception {
		assertGetterCalled(new Runnable() {
			public void run() {
				collection.equals(collection);
			}
		}, "Collection.equals(Object)", collection);
	}
	
	public void testEquals_RealmCheck() throws Exception {
		RealmTester.exerciseCurrent(new Runnable() {
			public void run() {
				collection.equals(collection);
			}
		}, (CurrentRealm) collection.getRealm());
	}

	public void testHashCode_GetterCalled() throws Exception {
		assertGetterCalled(new Runnable() {
			public void run() {
				collection.hashCode();
			}
		}, "Collection.hashCode()", collection);
	}
	
	public void testHashCode_RealmCheck() throws Exception {
		RealmTester.exerciseCurrent(new Runnable() {
			public void run() {
				collection.hashCode();
			}
		}, (CurrentRealm) collection.getRealm());
	}

	public void testGetElementType_ReturnsType() throws Exception {
		assertEquals(
				"Element type of the collection should be returned from IObservableCollection.getElementType()",
				delegate.getElementType(collection), collection
						.getElementType());
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.conformance.databinding;

import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.IObservableCollection;
import org.eclipse.core.databinding.observable.Realm;

/**
 * Abstract implementation of {@link IObservableCollectionContractDelegate}.
 * 
 * @since 3.2
 */
public abstract class AbstractObservableCollectionContractDelegate extends
		AbstractObservableContractDelegate implements
		IObservableCollectionContractDelegate {

	/**
	 * Invokes {@link #createObservableCollection(Realm, elementCount)}.
	 */
	public final IObservable createObservable(Realm realm) {
		return createObservableCollection(realm, 0);
	}
	
	public Object createElement(IObservableCollection collection) {
		//no op
		return null;
	}

	public Object getElementType(IObservableCollection collection) {
		//no op
		return null;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Brad Reynolds and others.
 * 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:
 *     Brad Reynolds - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.conformance.databinding;

import org.eclipse.core.databinding.observable.ChangeEvent;
import org.eclipse.core.databinding.observable.IChangeListener;
import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.ObservableTracker;
import org.eclipse.jface.tests.databinding.RealmTester;
import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;

/**
 * Tests for IObservable that don't require mutating the observable.
 * <p>
 * This class is experimental and can change at any time. It is recommended to
 * not subclass or assume the test names will not change. The only API that is
 * guaranteed to not change are the constructors. The tests will remain public
 * and not final in order to allow for consumers to turn off a test if needed by
 * subclassing.
 * </p>
 * 
 * @since 3.2
 */
public class ObservableContractTest extends ObservableDelegateTest {
	private IObservable observable;

	private IObservableContractDelegate delegate;

	public ObservableContractTest(IObservableContractDelegate delegate) {
		this(null, delegate);
	}

	public ObservableContractTest(String testName,
			IObservableContractDelegate delegate) {
		super(testName, delegate);
		
		this.delegate = delegate;
	}

	protected void setUp() throws Exception {
		super.setUp();
		observable = getObservable();
	}

	public void testGetRealm_NotNull() throws Exception {
		assertNotNull(formatFail("The observable's realm should not be null."), observable
				.getRealm());
	}

	public void testChange_ChangeEvent() throws Exception {
		ChangeListener listener = new ChangeListener();

		observable.addChangeListener(listener);
		delegate.change(observable);

		assertEquals(
				formatFail("A change in the observable should notify change listeners."),
				listener.count, 1);
	}

	public void testChange_EventObservable() throws Exception {
		ChangeListener listener = new ChangeListener();

		observable.addChangeListener(listener);
		delegate.change(observable);

		ChangeEvent event = listener.event;
		assertNotNull(formatFail("change event was null"), event);

		assertSame(
				formatFail("In the change event the source of the change should be the observable."),
				observable, event.getObservable());
	}

	public void testChange_RealmCheck() throws Exception {
		RealmTester.exerciseCurrent(new Runnable() {
			public void run() {
				delegate.change(observable);
			}			
		}, (CurrentRealm) observable.getRealm());
	}
	
	public void testChange_ObservableRealmIsTheCurrentRealm() throws Exception {
		ChangeListener listener = new ChangeListener();
		observable.addChangeListener(listener);

		delegate.change(observable);
		assertTrue(
				formatFail("On change the current realm should be the realm of the observable."),
				listener.isCurrentRealm);
	}

	public void testRemoveChangeListener_RemovesListener() throws Exception {
		ChangeListener listener = new ChangeListener();

		observable.addChangeListener(listener);
		delegate.change(observable);

		// precondition check
		assertEquals(formatFail("change did not notify listeners"), 1, listener.count);

		observable.removeChangeListener(listener);
		delegate.change(observable);

		assertEquals(
				formatFail("When a change listener is removed it should not still receive change events."),
				1, listener.count);
	}

	public void testIsStale_NotStale() throws Exception {
		delegate.setStale(observable, false);
		assertFalse(
				formatFail("When an observable is not stale isStale() should return false."),
				observable.isStale());
	}
	
	public void testIsStale_RealmChecks() throws Exception {
		RealmTester.exerciseCurrent(new Runnable() {
			public void run() {
				delegate.change(observable);
			}			
		}, (CurrentRealm) observable.getRealm());
	}

	/**
	 * Asserts that ObservableTracker.getterCalled(...) is invoked when the
	 * provided <code>runnable</code> is invoked.
	 * 
	 * @param runnable
	 * @param methodName
	 *            method name to display when displaying a message
	 * @param observable
	 *            observable that should be collected by ObservableTracker
	 */
	protected void assertGetterCalled(Runnable runnable,
			String methodName, IObservable observable) {
		IObservable[] observables = ObservableTracker.runAndMonitor(runnable,
				null, null);

		int count = 0;
		for (int i = 0; i < observables.length; i++) {
			if (observables[i] == observable) {
				count++;
			}
		}
		
		assertEquals(formatFail(methodName
				+ " should invoke ObservableTracker.getterCalled() once."), 1,
				count);
	}
	
	/* package */static class ChangeListener implements IChangeListener {
		int count;

		ChangeEvent event;

		boolean isCurrentRealm;

		public void handleChange(ChangeEvent event) {
			count++;
			this.event = event;
			this.isCurrentRealm = event.getObservable().getRealm().isCurrent();
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.conformance.databinding;

import java.util.Arrays;
import java.util.Collections;

import org.eclipse.core.databinding.observable.ChangeEvent;
import org.eclipse.core.databinding.observable.IChangeListener;
import org.eclipse.core.databinding.observable.IObservableCollection;
import org.eclipse.jface.tests.databinding.RealmTester;
import org.eclipse.jface.tests.databinding.EventTrackers.ChangeEventTracker;
import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;

/**
 * Mutability tests for IObservableCollection.
 * <p>
 * This class is experimental and can change at any time. It is recommended to
 * not subclass or assume the test names will not change. The only API that is
 * guaranteed to not change are the constructors. The tests will remain public
 * and not final in order to allow for consumers to turn off a test if needed by
 * subclassing.
 * </p>
 * 
 * @since 3.2
 */
public class MutableObservableCollectionContractTest extends ObservableDelegateTest {
	private IObservableCollectionContractDelegate delegate;

	private IObservableCollection collection;

	public MutableObservableCollectionContractTest(
			IObservableCollectionContractDelegate delegate) {
		super(delegate);
		this.delegate = delegate;
	}

	public MutableObservableCollectionContractTest(String name,
			IObservableCollectionContractDelegate delegate) {
		super(name, delegate);
		this.delegate = delegate;
	}

	protected void setUp() throws Exception {
		super.setUp();

		collection = (IObservableCollection) super.getObservable();
	}

	public void testAdd_ChangeEvent() throws Exception {
		assertChangeEventFired(new Runnable() {
			public void run() {
				collection.add(delegate.createElement(collection));
			}
		}, "Collection.add(Object)", collection);
	}
	
	public void testAdd_RealmCheck() throws Exception {
		RealmTester.exerciseCurrent(new Runnable() {
			public void run() {
				collection.add(delegate.createElement(collection));
			}
		}, (CurrentRealm) collection.getRealm());
	}

	public void testAdd_ChangeEventFiredAfterElementIsAdded() throws Exception {
		final Object element = delegate.createElement(collection);

		assertContainsDuringChangeEvent(new Runnable() {
			public void run() {
				collection.add(element);
			}
		}, "Collection.add(Object)", collection, element);
	}

	public void testAddAll_ChangeEvent() throws Exception {
		assertChangeEventFired(new Runnable() {
			public void run() {
				collection.addAll(Arrays.asList(new Object[] { delegate
						.createElement(collection) }));
			}
		}, "Collection.addAll(Collection)", collection);
	}
	
	public void testAddAll_RealmCheck() throws Exception {
		RealmTester.exerciseCurrent(new Runnable() {
			public void run() {
				collection.addAll(Arrays.asList(new Object[] { delegate
						.createElement(collection) }));
			}
		}, (CurrentRealm) collection.getRealm());
	}

	public void testAddAll_ChangeEventFiredAfterElementsAreAdded()
			throws Exception {
		final Object element = delegate.createElement(collection);

		assertContainsDuringChangeEvent(new Runnable() {
			public void run() {
				collection.addAll(Arrays.asList(new Object[] { element }));
			}
		}, "Collection.addAll(Collection)", collection, element);
	}

	public void testRemove_ChangeEvent() throws Exception {
		final Object element = delegate.createElement(collection);
		collection.add(element);

		assertChangeEventFired(new Runnable() {
			public void run() {
				collection.remove(element);
			}
		}, "Collection.remove(Object)", collection);
	}
	
	public void testRemove_RealmCheck() throws Exception {
		RealmTester.exerciseCurrent(new Runnable() {
			public void run() {
				collection.remove(delegate.createElement(collection));
			}
		}, (CurrentRealm) collection.getRealm());
	}

	public void testRemove_ChangeEventFiredAfterElementIsRemoved()
			throws Exception {
		final Object element = delegate.createElement(collection);
		collection.add(element);

		assertDoesNotContainDuringChangeEvent(new Runnable() {
			public void run() {
				collection.remove(element);
			}
		}, "Collection.remove(Object)", collection, element);
	}

	public void testRemoveAll_ChangeEvent() throws Exception {
		final Object element = delegate.createElement(collection);
		collection.add(element);

		assertChangeEventFired(new Runnable() {
			public void run() {
				collection.removeAll(Arrays.asList(new Object[] { element }));
			}
		}, "Collection.removeAll(Collection)", collection);
	}
	
	public void testRemoveAll_RealmCheck() throws Exception {
		RealmTester.exerciseCurrent(new Runnable() {
			public void run() {
				collection.removeAll(Arrays.asList(new Object[] { delegate.createElement(collection) }));
			}
		}, (CurrentRealm) collection.getRealm());
	}

	public void testRemoveAll_ChangeEventFiredAfterElementsAreRemoved()
			throws Exception {
		final Object element = delegate.createElement(collection);
		collection.add(element);

		assertDoesNotContainDuringChangeEvent(new Runnable() {
			public void run() {
				collection.removeAll(Arrays.asList(new Object[] { element }));
			}
		}, "Collection.removeAll(Collection)", collection, element);
	}

	public void testRetainAll_ChangeEvent() throws Exception {
		final Object element1 = delegate.createElement(collection);
		collection.add(element1);
		Object element2 = delegate.createElement(collection);
		collection.add(element2);

		assertChangeEventFired(new Runnable() {
			public void run() {
				collection.retainAll(Arrays.asList(new Object[] { element1 }));
			}

		}, "Collection.retainAll(Collection)", collection);
	}
	
	public void testRetainAll_RealmCheck() throws Exception {
		RealmTester.exerciseCurrent(new Runnable() {
			public void run() {
				collection.retainAll(Collections.EMPTY_LIST);
			}
		}, (CurrentRealm) collection.getRealm());
	}

	public void testRetainAll_ChangeEventFiredAfterElementsAreRetained()
			throws Exception {
		Object element1 = delegate.createElement(collection);
		collection.add(element1);
		Object element2 = delegate.createElement(collection);
		collection.add(element2);

		// precondition
		assertTrue(collection.contains(element1));
		assertTrue(collection.contains(element2));

		ContainsListener listener1 = new ContainsListener(collection, element1)
				.init();
		ContainsListener listener2 = new ContainsListener(collection, element2)
				.init();

		// set contains the the opposite of the expected outcome to ensure they
		// get set
		listener1.contains = false;
		listener2.contains = true;

		collection.retainAll(Arrays.asList(new Object[] { element1 }));
		assertTrue(
				formatFail("When Collection.retainAll(...) fires the change event the element should have been retained in the Collection."),
				listener1.contains);
		assertFalse(
				formatFail("When Collection.retainAll(...) fires the change event the element should have been removed from the Collection."),
				listener2.contains);
	}
	
	public void testClear_ChangeEvent() throws Exception {
		collection.add(delegate.createElement(collection));

		assertChangeEventFired(new Runnable() {
			public void run() {
				collection.clear();
			}
		}, "List.clear()", collection);
	}

	public void testClear_RealmCheck() throws Exception {
		RealmTester.exerciseCurrent(new Runnable() {
			public void run() {
				collection.clear();
			}
		}, (CurrentRealm) collection.getRealm());
	}

	public void testClear_ChangeEventFiredAfterElementIsRemoved()
			throws Exception {
		Object element = delegate.createElement(collection);
		collection.add(element);

		assertDoesNotContainDuringChangeEvent(new Runnable() {
			public void run() {
				collection.clear();
			}
		}, "List.clear()", collection, element);
	}

	/**
	 * Asserts that a ChangeEvent is fired once when the provided
	 * <code>runnable</code> is invoked and the source is the provided
	 * <code>collection</code>.
	 * 
	 * @param runnable
	 * @param methodName
	 * @param collection
	 */
	/* package */void assertChangeEventFired(Runnable runnable,
			String methodName, IObservableCollection collection) {
		ChangeEventTracker listener = new ChangeEventTracker();
		collection.addChangeListener(listener);
		runnable.run();

		assertEquals(formatFail(methodName + " should fire one ChangeEvent."), 1,
				listener.count);
		assertEquals(
				formatFail(methodName
						+ "'s change event observable should be the created Collection."),
				collection, listener.event.getObservable());
	}

	/**
	 * Asserts that when the change event is fired for the action contained in
	 * the <code>runnable</code> the change will have been applied to the
	 * <code>collection</code>.
	 * 
	 * @param runnable
	 * @param methodName
	 * @param collection
	 * @param elementContained
	 */
	/* package */void assertDoesNotContainDuringChangeEvent(Runnable runnable,
			String methodName, IObservableCollection collection,
			Object elementNotContained) {

		// precondition
		assertTrue(collection.contains(elementNotContained));

		ContainsListener listener = new ContainsListener(collection,
				elementNotContained).init();
		listener.contains = true;
		collection.remove(elementNotContained);
		assertFalse(
				formatFail(new StringBuffer("When ")
						.append(methodName)
						.append(
								" fires a change event the element should have been removed from the Collection.")
						.toString()), listener.contains);
	}

	/**
	 * Asserts that when the change event is fired for the action contained in
	 * the <code>runnable</code> the change will have been applied to the
	 * <code>collection</code>.
	 * 
	 * @param runnable
	 * @param methodName
	 * @param collection
	 * @param elementContained
	 */
	/* package */void assertContainsDuringChangeEvent(Runnable runnable,
			String methodName, IObservableCollection collection,
			Object elementContained) {
		ContainsListener listener = new ContainsListener(collection,
				elementContained).init();

		// precondition
		assertFalse(collection.contains(elementContained));
		runnable.run();

		assertTrue(
				formatFail(new StringBuffer("When ")
						.append(methodName)
						.append(
								" fires a change event the element should have been added to the Collection.")
						.toString()), listener.contains);
	}

	/* package */static class ContainsListener implements IChangeListener {
		boolean contains;

		final private Object element;

		final private IObservableCollection collection;

		ContainsListener(IObservableCollection collection, Object element) {
			this.element = element;
			this.collection = collection;
		}

		ContainsListener init() {
			collection.addChangeListener(this);
			return this;
		}

		public void handleChange(ChangeEvent event) {
			contains = collection.contains(element);
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.conformance.databinding;

import org.eclipse.core.databinding.observable.IObservableCollection;
import org.eclipse.core.databinding.observable.Realm;

/**
 * Delegate interface for an IObservableCollection.
 * 
 * <p>
 * This interface is not intended to be implemented by clients. Clients should
 * instead subclass one of the classes that implement this interface. Note that
 * direct implementers of this interface outside of the framework will be broken
 * in future releases when methods are added to this interface.
 * </p>
 * 
 * @since 1.1
 */
public interface IObservableCollectionContractDelegate extends
		IObservableContractDelegate {
	/**
	 * Creates a new observable collection with the provided
	 * <code>elementCount</code>.
	 * 
	 * @param realm realm of the collection
	 * @param elementCount
	 *            number of elements to initialize the collection with
	 * 
	 * @return new observable collection
	 */
	public IObservableCollection createObservableCollection(Realm realm, int elementCount);

	/**
	 * Creates a new element of the appropriate type for the provided
	 * <code>collection</code>. This element will be employed to assert the
	 * addition and removal of elements in the collection.
	 * 
	 * @param collection
	 * @return valid element for the collection
	 */
	public Object createElement(IObservableCollection collection);

	/**
	 * Returns the expected type of the elements in the collection.
	 * 
	 * @param collection
	 * @return element type
	 */
	public Object getElementType(IObservableCollection collection);
}




/*******************************************************************************
 * Copyright (c) 2007 Brad Reynolds and others.
 * 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:
 *     Brad Reynolds - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.conformance.databinding;

import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.Realm;

/**
 * Delegate interface for observables.
 * 
 * <p>
 * This interface is not intended to be implemented by clients. Clients should
 * instead subclass one of the classes that implement this interface. Note that
 * direct implementers of this interface outside of the framework will be broken
 * in future releases when methods are added to this interface.
 * </p>
 * 
 * @since 1.1
 */
public interface IObservableContractDelegate {
	/**
	 * Notifies the delegate of the start of a test.
	 */
	public void setUp();

	/**
	 * Notifies the delegate of the end of a test.
	 */
	public void tearDown();

	/**
	 * Invokes an operation to set the stale state of the provided
	 * <code>observable</code>.
	 * 
	 * @param observable
	 * @param stale
	 */
	public void setStale(IObservable observable, boolean stale);

	/**
	 * Creates a new observable.
	 * 
	 * @param realm realm of the observable
	 * @return observable
	 */
	public IObservable createObservable(Realm realm);

	/**
	 * Invokes a change operation on the observable resulting in a change event
	 * being fired from the observable.
	 * 
	 * @param observable
	 */
	public void change(IObservable observable);
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.conformance.databinding;

import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.jface.databinding.swt.SWTObservables;
import org.eclipse.jface.tests.databinding.RealmTester.DelegatingRealm;
import org.eclipse.swt.widgets.Display;

/**
 * Tests for IObservableValue that don't mutate the value.
 * <p>
 * This class is experimental and can change at any time. It is recommended to
 * not subclass or assume the test names will not change. The only API that is
 * guaranteed to not change are the constructors. The tests will remain public
 * and not final in order to allow for consumers to turn off a test if needed by
 * subclassing.
 * </p>
 * 
 * @since 3.2
 */
public class SWTObservableValueContractTest extends ObservableValueContractTest {
	private IObservableValueContractDelegate delegate;

	/**
	 * @param delegate
	 */
	public SWTObservableValueContractTest(
			IObservableValueContractDelegate delegate) {
		this(null, delegate);
	}

	public SWTObservableValueContractTest(String testName,
			IObservableValueContractDelegate delegate) {
		super(testName, delegate);
		this.delegate = delegate;
	}

	/**
	 * Creates a new observable passing the realm for the current display.
	 */
	protected IObservable doCreateObservable() {
		Display display = Display.getCurrent();
		if (display == null) {
			display = new Display();
		}
		DelegatingRealm delegateRealm = new DelegatingRealm(SWTObservables
				.getRealm(display));
		delegateRealm.setCurrent(true);

		return delegate.createObservable(delegateRealm);
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Brad Reynolds and others.
 * 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:
 *     Brad Reynolds - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.conformance.databinding;

import org.eclipse.core.databinding.observable.IObservable;

/**
 * Abstract implementation of {@link IObservableContractDelegate}.
 * 
 * @since 1.1
 */
public abstract class AbstractObservableContractDelegate implements
		IObservableContractDelegate {

	public void setUp() {
		// no op
	}

	public void tearDown() {
		// no op
	}

	public void change(IObservable observable) {
		// no op
	}

	public void setStale(IObservable observable, boolean stale) {
		// no op
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Brad Reynolds and others.
 * 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:
 *     Brad Reynolds - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.conformance.databinding;

import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.IStaleListener;
import org.eclipse.core.databinding.observable.StaleEvent;

/**
 * @since 3.3
 */
public class ObservableStaleContractTest extends ObservableDelegateTest {
	private IObservableContractDelegate delegate;
	private IObservable observable;
	
	public ObservableStaleContractTest(IObservableContractDelegate delegate) {
		this(null, delegate);
	}
	
	public ObservableStaleContractTest(String testName, IObservableContractDelegate delegate) {
		super(testName, delegate);
		this.delegate = delegate;
	}
	
	protected void setUp() throws Exception {
		super.setUp();
		
		observable = getObservable();
	}
	
	public void testIsStale_TrueWhenStale() throws Exception {
		delegate.setStale(observable, true);
		assertTrue(formatFail("When stale isStale() should return true."), observable.isStale());
	}
	
	public void testIsStale_FalseWhenNotStale() throws Exception {
		delegate.setStale(observable, false);
		assertFalse(formatFail("When not stale isStale() should return false."), observable.isStale());
	}

	public void testBecomingStaleFiresStaleEvent() throws Exception {
		StaleListener listener = new StaleListener();

		// precondition
		ensureStale(observable, false);

		observable.addStaleListener(listener);
		delegate.setStale(observable, true);

		assertEquals(formatFail("When becoming stale listeners should be notified."), 1, listener.count);
	}

	public void testStaleEventObservable() throws Exception {
		StaleListener listener = new StaleListener();

		// precondition
		ensureStale(observable, false);

		observable.addStaleListener(listener);
		delegate.setStale(observable, true);

		StaleEvent event = listener.event;
		assertNotNull(formatFail("stale event was null"), event);
		assertEquals(formatFail("When notifying listeners of becoming stale the observable should be the source of the event."), observable,
				event.getObservable());
	}

	public void testRemoveStaleListener_RemovesListener() throws Exception {
		StaleListener listener = new StaleListener();

		observable.addStaleListener(listener);
		ensureStale(observable, false);
		delegate.setStale(observable, true);

		// precondition check
		assertEquals(formatFail("set stale did not notify listeners"), 1, listener.count);

		observable.removeStaleListener(listener);
		ensureStale(observable, false);
		delegate.setStale(observable, true);

		assertEquals(formatFail("Once removed stale listeners should not be notified of becoming stale."), 1,
				listener.count);
	}

	public void testStaleListenersAreNotNotifiedWhenObservableIsNoLongerStale()
			throws Exception {
		ensureStale(observable, true);

		StaleListener listener = new StaleListener();
		observable.addStaleListener(listener);
		delegate.setStale(observable, false);

		assertEquals(formatFail("Stale listeners should not be notified when the stale state changes from true to false."), 0,
				listener.count);
	}

	public void testObservableRealmIsCurrentOnStale() throws Exception {
		ensureStale(observable, false);

		StaleListener listener = new StaleListener();
		observable.addStaleListener(listener);
		delegate.setStale(observable, true);

		assertTrue(formatFail("When notifying listeners of becoming stale the observable's realm should be the current realm."),
				listener.isCurrentRealm);
	}
	
	/**
	 * Ensures that stale is set to the provided state. Will throw an
	 * AssertionFailedError if setting of the state is unsuccessful.
	 * 
	 * @param observable
	 * @param stale
	 */
	private void ensureStale(IObservable observable, boolean stale) {
		if (observable.isStale() != stale) {
			delegate.setStale(observable, stale);
		}

		assertEquals(stale, observable.isStale());
	}
	
	/* package */static class StaleListener implements IStaleListener {
		int count;

		StaleEvent event;

		boolean isCurrentRealm;

		public void handleStale(StaleEvent staleEvent) {
			count++;
			this.event = staleEvent;
			this.isCurrentRealm = staleEvent.getObservable().getRealm()
					.isCurrent();
		}
	}

}




/*******************************************************************************
 * Copyright (c) 2007 Brad Reynolds and others.
 * 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:
 *     Brad Reynolds - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.conformance.databinding;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Iterator;
import java.util.LinkedHashSet;

import junit.framework.Test;
import junit.framework.TestSuite;

/**
 * Builds a test suite.
 * 
 * @since 1.1
 */
public class SuiteBuilder {
	private LinkedHashSet content;

	public SuiteBuilder() {
		content = new LinkedHashSet();
	}

	/**
	 * Adds all test methods from the provided <code>testCase</code> to the
	 * suite.
	 * 
	 * @param testCase
	 * @return builder
	 */
	public SuiteBuilder addTests(Class testCase) {
		content.add(testCase);
		return this;
	}

	/**
	 * Adds all test methods from the provided <code>testCase</code> with the
	 * provided <code>parameters</code>. A constructor must exist in the
	 * testCase that accepts a String as the first parameter followed by
	 * parameters matching the provided parameters. If an appropriate
	 * constructor is not found an exception will be thrown.
	 * 
	 * @param testCase
	 * @param parameters
	 * @return builder
	 */
	public SuiteBuilder addParameterizedTests(Class testCase,
			Object[] parameters) {

		Constructor constructor = findConstructor(testCase, parameters);
		if (constructor == null) {
			throw new IllegalArgumentException(
					"The parameters provided don't match a constructor found in ["
							+ testCase.getName() + "]");
		}

		content.add(new ParameterizedTest(testCase, constructor, parameters));

		return this;
	}

	/**
	 * Convenience method for invoking
	 * {@link #addParameterizedTests(Class, Object[])} with a delegate.
	 * 
	 * @param testCase
	 * @param delegate
	 * @return
	 */
	public SuiteBuilder addObservableContractTest(Class testCase,
			IObservableContractDelegate delegate) {

		addParameterizedTests(testCase, new Object[] {delegate});
		return this;
	}

	/**
	 * Builds a new TestSuite out of the tests.
	 * 
	 * @return suite
	 */
	public TestSuite build() {
		TestSuite suite = new TestSuite();

		for (Iterator it = content.iterator(); it.hasNext();) {
			Object o = it.next();
			if (o instanceof Class) {
				suite.addTestSuite((Class) o);
			} else if (o instanceof ParameterizedTest) {
				ParameterizedTest test = (ParameterizedTest) o;

				Method[] methods = test.testClass.getMethods();
				for (int i = 0; i < methods.length; i++) {
					String name = methods[i].getName();
					if (name.startsWith("test")) {
						try {
							suite.addTest((Test) test.constructor
									.newInstance(toParamArray(name,
											test.parameters)));
						} catch (Exception e) {
							throw new RuntimeException(e);
						}
					}
				}
			}
		}

		return suite;
	}

	private Object[] toParamArray(String testName, Object[] parameters) {
		Object[] result = new Object[parameters.length + 1];
		result[0] = testName;
		System.arraycopy(parameters, 0, result, 1, parameters.length);
		return result;
	}

	/**
	 * Returns the constructor that has a String as the first parameters and
	 * then matches the type of the parameters.
	 * 
	 * @param parameters
	 * @return
	 */
	private static Constructor findConstructor(Class clazz, Object[] parameters) {
		Constructor[] constructors = clazz.getConstructors();
		int expectedParametersLength = parameters.length + 1;

		for (int i = 0; i < constructors.length; i++) {
			Constructor constructor = constructors[i];
			Class[] types = constructor.getParameterTypes();

			if (types.length != expectedParametersLength
					|| !String.class.equals(types[0])) {
				continue;
			}

			boolean skip = false;
			for (int j = 1; j < types.length; j++) {
				Class type = types[j];
				if (!type.isInstance(parameters[j - 1])) {
					skip = true;
					break;
				}
			}

			if (!skip) {
				return constructor;
			}
		}

		return null;
	}

	/* package */static class ParameterizedTest {
		final Constructor constructor;

		final Object[] parameters;

		private Class testClass;

		ParameterizedTest(Class testClass, Constructor constructor,
				Object[] parameterss) {
			this.testClass = testClass;
			this.constructor = constructor;
			this.parameters = parameterss;
		}
	}
}

Lines 25-35 Link Here

(-)src/org/eclipse/core/tests/databinding/observable/list/AbstractObservableListTest.java (-5 / +5 lines)
25	import org.eclipse.core.databinding.observable.Realm;	25	import org.eclipse.core.databinding.observable.Realm;
26	import org.eclipse.core.databinding.observable.list.AbstractObservableList;	26	import org.eclipse.core.databinding.observable.list.AbstractObservableList;
27	import org.eclipse.core.databinding.observable.list.ListDiff;	27	import org.eclipse.core.databinding.observable.list.ListDiff;
28	import org.eclipse.jface.conformance.databinding.AbstractObservableCollectionContractDelegate;	28	import org.eclipse.jface.databinding.conformance.ObservableListContractTest;
29	import org.eclipse.jface.conformance.databinding.ObservableListContractTest;	29	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableCollectionContractDelegate;
30	import org.eclipse.jface.conformance.databinding.SuiteBuilder;	30	import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
31	import org.eclipse.jface.tests.databinding.RealmTester;	31	import org.eclipse.jface.databinding.conformance.util.RealmTester;
32	import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;	32	import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
33		33
34	/**	34	/**
35	* @since 3.2	35	* @since 3.2

Lines 24-34 Link Here

(-)src/org/eclipse/core/tests/databinding/observable/list/ObservableListTest.java (-5 / +5 lines)
24	import org.eclipse.core.databinding.observable.Realm;	24	import org.eclipse.core.databinding.observable.Realm;
25	import org.eclipse.core.databinding.observable.list.ListDiff;	25	import org.eclipse.core.databinding.observable.list.ListDiff;
26	import org.eclipse.core.databinding.observable.list.ObservableList;	26	import org.eclipse.core.databinding.observable.list.ObservableList;
27	import org.eclipse.jface.conformance.databinding.AbstractObservableCollectionContractDelegate;	27	import org.eclipse.jface.databinding.conformance.ObservableListContractTest;
28	import org.eclipse.jface.conformance.databinding.ObservableListContractTest;	28	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableCollectionContractDelegate;
29	import org.eclipse.jface.conformance.databinding.SuiteBuilder;	29	import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
30	import org.eclipse.jface.tests.databinding.RealmTester;	30	import org.eclipse.jface.databinding.conformance.util.RealmTester;
31	import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;	31	import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
32		32
33	/**	33	/**
34	* @since 3.2	34	* @since 3.2

Lines 22-34 Link Here

(-)src/org/eclipse/core/tests/databinding/observable/list/WritableListTest.java (-6 / +6 lines)
22	import org.eclipse.core.databinding.observable.IObservableCollection;	22	import org.eclipse.core.databinding.observable.IObservableCollection;
23	import org.eclipse.core.databinding.observable.Realm;	23	import org.eclipse.core.databinding.observable.Realm;
24	import org.eclipse.core.databinding.observable.list.WritableList;	24	import org.eclipse.core.databinding.observable.list.WritableList;
25	import org.eclipse.jface.conformance.databinding.AbstractObservableCollectionContractDelegate;	25	import org.eclipse.jface.databinding.conformance.MutableObservableListContractTest;
26	import org.eclipse.jface.conformance.databinding.MutableObservableListContractTest;	26	import org.eclipse.jface.databinding.conformance.ObservableListContractTest;
27	import org.eclipse.jface.conformance.databinding.ObservableListContractTest;	27	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableCollectionContractDelegate;
28	import org.eclipse.jface.conformance.databinding.SuiteBuilder;	28	import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
		29	import org.eclipse.jface.databinding.conformance.util.RealmTester;
		30	import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
29	import org.eclipse.jface.databinding.swt.SWTObservables;	31	import org.eclipse.jface.databinding.swt.SWTObservables;
30	import org.eclipse.jface.tests.databinding.RealmTester;
31	import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;
32	import org.eclipse.swt.widgets.Display;	32	import org.eclipse.swt.widgets.Display;
33		33
34	/**	34	/**

Lines 16-26 Link Here

(-)src/org/eclipse/jface/tests/internal/databinding/internal/swt/SpinnerObservableValueMaxTest.java (-5 / +5 lines)
16	import org.eclipse.core.databinding.observable.IObservable;	16	import org.eclipse.core.databinding.observable.IObservable;
17	import org.eclipse.core.databinding.observable.Realm;	17	import org.eclipse.core.databinding.observable.Realm;
18	import org.eclipse.core.databinding.observable.value.IObservableValue;	18	import org.eclipse.core.databinding.observable.value.IObservableValue;
19	import org.eclipse.jface.conformance.databinding.AbstractObservableValueContractDelegate;	19	import org.eclipse.jface.databinding.conformance.ObservableDelegateTest;
20	import org.eclipse.jface.conformance.databinding.ObservableDelegateTest;	20	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
21	import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;	21	import org.eclipse.jface.databinding.conformance.swt.SWTMutableObservableValueContractTest;
22	import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;	22	import org.eclipse.jface.databinding.conformance.swt.SWTObservableValueContractTest;
23	import org.eclipse.jface.conformance.databinding.SuiteBuilder;	23	import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
24	import org.eclipse.jface.databinding.swt.SWTObservables;	24	import org.eclipse.jface.databinding.swt.SWTObservables;
25	import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;	25	import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;
26	import org.eclipse.jface.internal.databinding.internal.swt.SpinnerObservableValue;	26	import org.eclipse.jface.internal.databinding.internal.swt.SpinnerObservableValue;

Lines 16-26 Link Here

(-)src/org/eclipse/jface/tests/internal/databinding/internal/swt/ScaleObservableValueMaxTest.java (-5 / +5 lines)
16	import org.eclipse.core.databinding.observable.IObservable;	16	import org.eclipse.core.databinding.observable.IObservable;
17	import org.eclipse.core.databinding.observable.Realm;	17	import org.eclipse.core.databinding.observable.Realm;
18	import org.eclipse.core.databinding.observable.value.IObservableValue;	18	import org.eclipse.core.databinding.observable.value.IObservableValue;
19	import org.eclipse.jface.conformance.databinding.AbstractObservableValueContractDelegate;	19	import org.eclipse.jface.databinding.conformance.ObservableDelegateTest;
20	import org.eclipse.jface.conformance.databinding.ObservableDelegateTest;	20	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
21	import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;	21	import org.eclipse.jface.databinding.conformance.swt.SWTMutableObservableValueContractTest;
22	import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;	22	import org.eclipse.jface.databinding.conformance.swt.SWTObservableValueContractTest;
23	import org.eclipse.jface.conformance.databinding.SuiteBuilder;	23	import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
24	import org.eclipse.jface.databinding.swt.SWTObservables;	24	import org.eclipse.jface.databinding.swt.SWTObservables;
25	import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;	25	import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;
26	import org.eclipse.jface.internal.databinding.internal.swt.ScaleObservableValue;	26	import org.eclipse.jface.internal.databinding.internal.swt.ScaleObservableValue;




import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
import org.eclipse.jface.databinding.conformance.swt.SWTMutableObservableValueContractTest;
import org.eclipse.jface.databinding.conformance.swt.SWTObservableValueContractTest;
import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;
import org.eclipse.jface.databinding.swt.ISWTObservable;
import org.eclipse.jface.databinding.swt.SWTObservables;
import org.eclipse.jface.internal.databinding.internal.swt.ComboObservableValue;
import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;
import org.eclipse.jface.tests.databinding.EventTrackers.ValueChangeEventTracker;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Display;

		IObservableValue observable = delegate
				.createObservableValue(SWTObservables.getRealm(Display
						.getDefault()));
		ValueChangeEventTracker listener = ValueChangeEventTracker
				.observe(observable);

		combo.setText((String) delegate.createValue(observable));





import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
import org.eclipse.jface.databinding.conformance.swt.SWTMutableObservableValueContractTest;
import org.eclipse.jface.databinding.conformance.swt.SWTObservableValueContractTest;
import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;
import org.eclipse.jface.databinding.swt.ISWTObservable;
import org.eclipse.jface.databinding.swt.SWTObservables;
import org.eclipse.jface.internal.databinding.internal.swt.ComboObservableValue;
import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;
import org.eclipse.jface.tests.databinding.EventTrackers.ValueChangeEventTracker;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Display;

		IObservableValue observable = (IObservableValue) delegate
				.createObservable(SWTObservables.getRealm(Display.getDefault()));

		ValueChangeEventTracker listener = ValueChangeEventTracker
				.observe(observable);
		combo.select(0);
		combo.notifyListeners(SWT.Selection, null);


Lines 12-21 Link Here

(-)src/org/eclipse/jface/tests/internal/databinding/internal/swt/ComboObservableValueTest.java (-1 / +1 lines)
12		12
13	package org.eclipse.jface.tests.internal.databinding.internal.swt;	13	package org.eclipse.jface.tests.internal.databinding.internal.swt;
14		14
		15	import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;
15	import org.eclipse.jface.internal.databinding.internal.swt.ComboObservableValue;	16	import org.eclipse.jface.internal.databinding.internal.swt.ComboObservableValue;
16	import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;	17	import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;
17	import org.eclipse.jface.tests.databinding.AbstractSWTTestCase;	18	import org.eclipse.jface.tests.databinding.AbstractSWTTestCase;
18	import org.eclipse.jface.tests.databinding.EventTrackers.ValueChangeEventTracker;
19	import org.eclipse.swt.SWT;	19	import org.eclipse.swt.SWT;
20	import org.eclipse.swt.widgets.Combo;	20	import org.eclipse.swt.widgets.Combo;
21		21

Lines 16-26 Link Here

(-)src/org/eclipse/jface/tests/internal/databinding/internal/swt/ScaleObservableValueSelectionTest.java (-5 / +5 lines)
16	import org.eclipse.core.databinding.observable.IObservable;	16	import org.eclipse.core.databinding.observable.IObservable;
17	import org.eclipse.core.databinding.observable.Realm;	17	import org.eclipse.core.databinding.observable.Realm;
18	import org.eclipse.core.databinding.observable.value.IObservableValue;	18	import org.eclipse.core.databinding.observable.value.IObservableValue;
19	import org.eclipse.jface.conformance.databinding.AbstractObservableValueContractDelegate;	19	import org.eclipse.jface.databinding.conformance.ObservableDelegateTest;
20	import org.eclipse.jface.conformance.databinding.ObservableDelegateTest;	20	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
21	import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;	21	import org.eclipse.jface.databinding.conformance.swt.SWTMutableObservableValueContractTest;
22	import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;	22	import org.eclipse.jface.databinding.conformance.swt.SWTObservableValueContractTest;
23	import org.eclipse.jface.conformance.databinding.SuiteBuilder;	23	import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
24	import org.eclipse.jface.databinding.swt.SWTObservables;	24	import org.eclipse.jface.databinding.swt.SWTObservables;
25	import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;	25	import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;
26	import org.eclipse.jface.internal.databinding.internal.swt.ScaleObservableValue;	26	import org.eclipse.jface.internal.databinding.internal.swt.ScaleObservableValue;

Lines 16-26 Link Here

(-)src/org/eclipse/jface/tests/internal/databinding/internal/swt/LabelObservableValueTest.java (-5 / +5 lines)
16	import org.eclipse.core.databinding.observable.IObservable;	16	import org.eclipse.core.databinding.observable.IObservable;
17	import org.eclipse.core.databinding.observable.Realm;	17	import org.eclipse.core.databinding.observable.Realm;
18	import org.eclipse.core.databinding.observable.value.IObservableValue;	18	import org.eclipse.core.databinding.observable.value.IObservableValue;
19	import org.eclipse.jface.conformance.databinding.AbstractObservableValueContractDelegate;	19	import org.eclipse.jface.databinding.conformance.ObservableDelegateTest;
20	import org.eclipse.jface.conformance.databinding.ObservableDelegateTest;	20	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
21	import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;	21	import org.eclipse.jface.databinding.conformance.swt.SWTMutableObservableValueContractTest;
22	import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;	22	import org.eclipse.jface.databinding.conformance.swt.SWTObservableValueContractTest;
23	import org.eclipse.jface.conformance.databinding.SuiteBuilder;	23	import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
24	import org.eclipse.jface.databinding.swt.SWTObservables;	24	import org.eclipse.jface.databinding.swt.SWTObservables;
25	import org.eclipse.jface.internal.databinding.internal.swt.LabelObservableValue;	25	import org.eclipse.jface.internal.databinding.internal.swt.LabelObservableValue;
26	import org.eclipse.swt.SWT;	26	import org.eclipse.swt.SWT;




import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
import org.eclipse.jface.databinding.conformance.swt.SWTMutableObservableValueContractTest;
import org.eclipse.jface.databinding.conformance.swt.SWTObservableValueContractTest;
import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;
import org.eclipse.jface.databinding.swt.ISWTObservable;
import org.eclipse.jface.databinding.swt.SWTObservables;
import org.eclipse.jface.internal.databinding.internal.swt.CComboObservableValue;
import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;
import org.eclipse.jface.tests.databinding.EventTrackers.ValueChangeEventTracker;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CCombo;
import org.eclipse.swt.widgets.Display;

		IObservableValue observable = (IObservableValue) delegate
				.createObservable(SWTObservables.getRealm(Display.getDefault()));

		ValueChangeEventTracker listener = ValueChangeEventTracker.observe(observable);
				.register(observable);
		combo.select(0);

		assertEquals("Observable was not notified.", 1, listener.count);

Lines 16-26 Link Here

(-)src/org/eclipse/jface/tests/internal/databinding/internal/swt/TableSingleSelectionObservableValueTest.java (-5 / +5 lines)
16	import org.eclipse.core.databinding.observable.IObservable;	16	import org.eclipse.core.databinding.observable.IObservable;
17	import org.eclipse.core.databinding.observable.Realm;	17	import org.eclipse.core.databinding.observable.Realm;
18	import org.eclipse.core.databinding.observable.value.IObservableValue;	18	import org.eclipse.core.databinding.observable.value.IObservableValue;
19	import org.eclipse.jface.conformance.databinding.AbstractObservableValueContractDelegate;	19	import org.eclipse.jface.databinding.conformance.ObservableDelegateTest;
20	import org.eclipse.jface.conformance.databinding.ObservableDelegateTest;	20	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
21	import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;	21	import org.eclipse.jface.databinding.conformance.swt.SWTMutableObservableValueContractTest;
22	import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;	22	import org.eclipse.jface.databinding.conformance.swt.SWTObservableValueContractTest;
23	import org.eclipse.jface.conformance.databinding.SuiteBuilder;	23	import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
24	import org.eclipse.jface.databinding.swt.SWTObservables;	24	import org.eclipse.jface.databinding.swt.SWTObservables;
25	import org.eclipse.jface.internal.databinding.internal.swt.TableSingleSelectionObservableValue;	25	import org.eclipse.jface.internal.databinding.internal.swt.TableSingleSelectionObservableValue;
26	import org.eclipse.jface.util.Assert;	26	import org.eclipse.jface.util.Assert;

Lines 16-26 Link Here

(-)src/org/eclipse/jface/tests/internal/databinding/internal/swt/TextEditableObservableValueTest.java (-5 / +5 lines)
16	import org.eclipse.core.databinding.observable.IObservable;	16	import org.eclipse.core.databinding.observable.IObservable;
17	import org.eclipse.core.databinding.observable.Realm;	17	import org.eclipse.core.databinding.observable.Realm;
18	import org.eclipse.core.databinding.observable.value.IObservableValue;	18	import org.eclipse.core.databinding.observable.value.IObservableValue;
19	import org.eclipse.jface.conformance.databinding.AbstractObservableValueContractDelegate;	19	import org.eclipse.jface.databinding.conformance.ObservableDelegateTest;
20	import org.eclipse.jface.conformance.databinding.ObservableDelegateTest;	20	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
21	import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;	21	import org.eclipse.jface.databinding.conformance.swt.SWTMutableObservableValueContractTest;
22	import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;	22	import org.eclipse.jface.databinding.conformance.swt.SWTObservableValueContractTest;
23	import org.eclipse.jface.conformance.databinding.SuiteBuilder;	23	import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
24	import org.eclipse.jface.internal.databinding.internal.swt.TextEditableObservableValue;	24	import org.eclipse.jface.internal.databinding.internal.swt.TextEditableObservableValue;
25	import org.eclipse.swt.SWT;	25	import org.eclipse.swt.SWT;
26	import org.eclipse.swt.widgets.Shell;	26	import org.eclipse.swt.widgets.Shell;

Lines 16-26 Link Here

(-)src/org/eclipse/jface/tests/internal/databinding/internal/swt/ScaleObservableValueMinTest.java (-5 / +5 lines)
16	import org.eclipse.core.databinding.observable.IObservable;	16	import org.eclipse.core.databinding.observable.IObservable;
17	import org.eclipse.core.databinding.observable.Realm;	17	import org.eclipse.core.databinding.observable.Realm;
18	import org.eclipse.core.databinding.observable.value.IObservableValue;	18	import org.eclipse.core.databinding.observable.value.IObservableValue;
19	import org.eclipse.jface.conformance.databinding.AbstractObservableValueContractDelegate;	19	import org.eclipse.jface.databinding.conformance.ObservableDelegateTest;
20	import org.eclipse.jface.conformance.databinding.ObservableDelegateTest;	20	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
21	import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;	21	import org.eclipse.jface.databinding.conformance.swt.SWTMutableObservableValueContractTest;
22	import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;	22	import org.eclipse.jface.databinding.conformance.swt.SWTObservableValueContractTest;
23	import org.eclipse.jface.conformance.databinding.SuiteBuilder;	23	import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
24	import org.eclipse.jface.databinding.swt.SWTObservables;	24	import org.eclipse.jface.databinding.swt.SWTObservables;
25	import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;	25	import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;
26	import org.eclipse.jface.internal.databinding.internal.swt.ScaleObservableValue;	26	import org.eclipse.jface.internal.databinding.internal.swt.ScaleObservableValue;

Lines 12-21 Link Here

(-)src/org/eclipse/jface/tests/internal/databinding/internal/swt/SpinnerObservableValueTest.java (-1 / +1 lines)
12		12
13	package org.eclipse.jface.tests.internal.databinding.internal.swt;	13	package org.eclipse.jface.tests.internal.databinding.internal.swt;
14		14
		15	import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;
15	import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;	16	import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;
16	import org.eclipse.jface.internal.databinding.internal.swt.SpinnerObservableValue;	17	import org.eclipse.jface.internal.databinding.internal.swt.SpinnerObservableValue;
17	import org.eclipse.jface.tests.databinding.AbstractSWTTestCase;	18	import org.eclipse.jface.tests.databinding.AbstractSWTTestCase;
18	import org.eclipse.jface.tests.databinding.EventTrackers.ValueChangeEventTracker;
19	import org.eclipse.swt.SWT;	19	import org.eclipse.swt.SWT;
20	import org.eclipse.swt.widgets.Spinner;	20	import org.eclipse.swt.widgets.Spinner;
21		21




import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
import org.eclipse.jface.databinding.conformance.swt.SWTMutableObservableValueContractTest;
import org.eclipse.jface.databinding.conformance.swt.SWTObservableValueContractTest;
import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;
import org.eclipse.jface.internal.databinding.internal.swt.ButtonObservableValue;
import org.eclipse.jface.tests.databinding.AbstractSWTTestCase;
import org.eclipse.jface.tests.databinding.EventTrackers.ValueChangeEventTracker;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Shell;

Lines 14-22 Link Here

(-)src/org/eclipse/jface/tests/internal/databinding/internal/swt/TextObservableValueTest.java (-1 / +1 lines)
14		14
15	package org.eclipse.jface.tests.internal.databinding.internal.swt;	15	package org.eclipse.jface.tests.internal.databinding.internal.swt;
16		16
		17	import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;
17	import org.eclipse.jface.internal.databinding.internal.swt.TextObservableValue;	18	import org.eclipse.jface.internal.databinding.internal.swt.TextObservableValue;
18	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;	19	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
19	import org.eclipse.jface.tests.databinding.EventTrackers.ValueChangeEventTracker;
20	import org.eclipse.swt.SWT;	20	import org.eclipse.swt.SWT;
21	import org.eclipse.swt.widgets.Shell;	21	import org.eclipse.swt.widgets.Shell;
22	import org.eclipse.swt.widgets.Text;	22	import org.eclipse.swt.widgets.Text;




import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
import org.eclipse.jface.databinding.conformance.swt.SWTMutableObservableValueContractTest;
import org.eclipse.jface.databinding.conformance.swt.SWTObservableValueContractTest;
import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;
import org.eclipse.jface.databinding.swt.ISWTObservable;
import org.eclipse.jface.databinding.swt.SWTObservables;
import org.eclipse.jface.internal.databinding.internal.swt.CComboObservableValue;
import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;
import org.eclipse.jface.tests.databinding.EventTrackers.ValueChangeEventTracker;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CCombo;
import org.eclipse.swt.widgets.Display;

		IObservableValue observable = delegate
				.createObservableValue(SWTObservables.getRealm(Display
						.getDefault()));
		ValueChangeEventTracker listener = ValueChangeEventTracker
				.observe(observable);

		combo.setText((String) delegate.createValue(observable));


Lines 17-26 Link Here

(-)src/org/eclipse/jface/tests/internal/databinding/internal/swt/CLabelObservableValueTest.java (-4 / +4 lines)
17	import org.eclipse.core.databinding.observable.IObservable;	17	import org.eclipse.core.databinding.observable.IObservable;
18	import org.eclipse.core.databinding.observable.Realm;	18	import org.eclipse.core.databinding.observable.Realm;
19	import org.eclipse.core.databinding.observable.value.IObservableValue;	19	import org.eclipse.core.databinding.observable.value.IObservableValue;
20	import org.eclipse.jface.conformance.databinding.AbstractObservableValueContractDelegate;	20	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
21	import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;	21	import org.eclipse.jface.databinding.conformance.swt.SWTMutableObservableValueContractTest;
22	import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;	22	import org.eclipse.jface.databinding.conformance.swt.SWTObservableValueContractTest;
23	import org.eclipse.jface.conformance.databinding.SuiteBuilder;	23	import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
24	import org.eclipse.jface.databinding.swt.SWTObservables;	24	import org.eclipse.jface.databinding.swt.SWTObservables;
25	import org.eclipse.jface.internal.databinding.internal.swt.CLabelObservableValue;	25	import org.eclipse.jface.internal.databinding.internal.swt.CLabelObservableValue;
26	import org.eclipse.swt.SWT;	26	import org.eclipse.swt.SWT;

Lines 16-26 Link Here

(-)src/org/eclipse/jface/tests/internal/databinding/internal/swt/SpinnerObservableValueMinTest.java (-5 / +5 lines)
16	import org.eclipse.core.databinding.observable.IObservable;	16	import org.eclipse.core.databinding.observable.IObservable;
17	import org.eclipse.core.databinding.observable.Realm;	17	import org.eclipse.core.databinding.observable.Realm;
18	import org.eclipse.core.databinding.observable.value.IObservableValue;	18	import org.eclipse.core.databinding.observable.value.IObservableValue;
19	import org.eclipse.jface.conformance.databinding.AbstractObservableValueContractDelegate;	19	import org.eclipse.jface.databinding.conformance.ObservableDelegateTest;
20	import org.eclipse.jface.conformance.databinding.ObservableDelegateTest;	20	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
21	import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;	21	import org.eclipse.jface.databinding.conformance.swt.SWTMutableObservableValueContractTest;
22	import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;	22	import org.eclipse.jface.databinding.conformance.swt.SWTObservableValueContractTest;
23	import org.eclipse.jface.conformance.databinding.SuiteBuilder;	23	import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
24	import org.eclipse.jface.databinding.swt.SWTObservables;	24	import org.eclipse.jface.databinding.swt.SWTObservables;
25	import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;	25	import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;
26	import org.eclipse.jface.internal.databinding.internal.swt.SpinnerObservableValue;	26	import org.eclipse.jface.internal.databinding.internal.swt.SpinnerObservableValue;

Lines 17-26 Link Here

(-)src/org/eclipse/jface/tests/internal/databinding/internal/swt/CComboSingleSelectionObservableValueTest.java (-4 / +4 lines)
17	import org.eclipse.core.databinding.observable.IObservable;	17	import org.eclipse.core.databinding.observable.IObservable;
18	import org.eclipse.core.databinding.observable.Realm;	18	import org.eclipse.core.databinding.observable.Realm;
19	import org.eclipse.core.databinding.observable.value.IObservableValue;	19	import org.eclipse.core.databinding.observable.value.IObservableValue;
20	import org.eclipse.jface.conformance.databinding.AbstractObservableValueContractDelegate;	20	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
21	import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;	21	import org.eclipse.jface.databinding.conformance.swt.SWTMutableObservableValueContractTest;
22	import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;	22	import org.eclipse.jface.databinding.conformance.swt.SWTObservableValueContractTest;
23	import org.eclipse.jface.conformance.databinding.SuiteBuilder;	23	import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
24	import org.eclipse.jface.databinding.swt.ISWTObservable;	24	import org.eclipse.jface.databinding.swt.ISWTObservable;
25	import org.eclipse.jface.internal.databinding.internal.swt.CComboSingleSelectionObservableValue;	25	import org.eclipse.jface.internal.databinding.internal.swt.CComboSingleSelectionObservableValue;
26	import org.eclipse.jface.tests.databinding.AbstractSWTTestCase;	26	import org.eclipse.jface.tests.databinding.AbstractSWTTestCase;

Lines 12-21 Link Here

(-)src/org/eclipse/jface/tests/internal/databinding/internal/swt/CComboObservableValueTest.java (-1 / +1 lines)
12		12
13	package org.eclipse.jface.tests.internal.databinding.internal.swt;	13	package org.eclipse.jface.tests.internal.databinding.internal.swt;
14		14
		15	import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;
15	import org.eclipse.jface.internal.databinding.internal.swt.CComboObservableValue;	16	import org.eclipse.jface.internal.databinding.internal.swt.CComboObservableValue;
16	import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;	17	import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;
17	import org.eclipse.jface.tests.databinding.AbstractSWTTestCase;	18	import org.eclipse.jface.tests.databinding.AbstractSWTTestCase;
18	import org.eclipse.jface.tests.databinding.EventTrackers.ValueChangeEventTracker;
19	import org.eclipse.swt.SWT;	19	import org.eclipse.swt.SWT;
20	import org.eclipse.swt.custom.CCombo;	20	import org.eclipse.swt.custom.CCombo;
21		21

Lines 16-26 Link Here

(-)src/org/eclipse/jface/tests/internal/databinding/internal/swt/SpinnerObservableValueSelectionTest.java (-5 / +5 lines)
16	import org.eclipse.core.databinding.observable.IObservable;	16	import org.eclipse.core.databinding.observable.IObservable;
17	import org.eclipse.core.databinding.observable.Realm;	17	import org.eclipse.core.databinding.observable.Realm;
18	import org.eclipse.core.databinding.observable.value.IObservableValue;	18	import org.eclipse.core.databinding.observable.value.IObservableValue;
19	import org.eclipse.jface.conformance.databinding.AbstractObservableValueContractDelegate;	19	import org.eclipse.jface.databinding.conformance.ObservableDelegateTest;
20	import org.eclipse.jface.conformance.databinding.ObservableDelegateTest;	20	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
21	import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;	21	import org.eclipse.jface.databinding.conformance.swt.SWTMutableObservableValueContractTest;
22	import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;	22	import org.eclipse.jface.databinding.conformance.swt.SWTObservableValueContractTest;
23	import org.eclipse.jface.conformance.databinding.SuiteBuilder;	23	import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
24	import org.eclipse.jface.databinding.swt.SWTObservables;	24	import org.eclipse.jface.databinding.swt.SWTObservables;
25	import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;	25	import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;
26	import org.eclipse.jface.internal.databinding.internal.swt.SpinnerObservableValue;	26	import org.eclipse.jface.internal.databinding.internal.swt.SpinnerObservableValue;

Lines 19-27 Link Here

(-)src/org/eclipse/core/tests/databinding/observable/map/WritableMapTest.java (-3 / +3 lines)
19	import org.eclipse.core.databinding.observable.Realm;	19	import org.eclipse.core.databinding.observable.Realm;
20	import org.eclipse.core.databinding.observable.map.MapChangeEvent;	20	import org.eclipse.core.databinding.observable.map.MapChangeEvent;
21	import org.eclipse.core.databinding.observable.map.WritableMap;	21	import org.eclipse.core.databinding.observable.map.WritableMap;
22	import org.eclipse.jface.tests.databinding.RealmTester;	22	import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
23	import org.eclipse.jface.tests.databinding.EventTrackers.MapChangeEventTracker;	23	import org.eclipse.jface.databinding.conformance.util.MapChangeEventTracker;
24	import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;	24	import org.eclipse.jface.databinding.conformance.util.RealmTester;
25		25
26	/**	26	/**
27	* @since 3.2	27	* @since 3.2

Lines 20-27 Link Here

(-)src/org/eclipse/core/tests/databinding/observable/map/ObservableMapTest.java (-2 / +2 lines)
20	import org.eclipse.core.databinding.observable.map.MapChangeEvent;	20	import org.eclipse.core.databinding.observable.map.MapChangeEvent;
21	import org.eclipse.core.databinding.observable.map.MapDiff;	21	import org.eclipse.core.databinding.observable.map.MapDiff;
22	import org.eclipse.core.databinding.observable.map.ObservableMap;	22	import org.eclipse.core.databinding.observable.map.ObservableMap;
23	import org.eclipse.jface.tests.databinding.RealmTester;	23	import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
24	import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;	24	import org.eclipse.jface.databinding.conformance.util.RealmTester;
25		25
26	/**	26	/**
27	* @since 3.2	27	* @since 3.2

Lines 17-24 Link Here

(-)src/org/eclipse/core/tests/databinding/observable/map/AbstractObservableMapTest.java (-2 / +2 lines)
17		17
18	import org.eclipse.core.databinding.observable.map.AbstractObservableMap;	18	import org.eclipse.core.databinding.observable.map.AbstractObservableMap;
19	import org.eclipse.core.databinding.observable.map.MapDiff;	19	import org.eclipse.core.databinding.observable.map.MapDiff;
20	import org.eclipse.jface.tests.databinding.RealmTester;	20	import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
21	import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;	21	import org.eclipse.jface.databinding.conformance.util.RealmTester;
22		22
23	/**	23	/**
24	* @since 3.2	24	* @since 3.2

Lines 20-28 Link Here

(-)src/org/eclipse/core/tests/databinding/observable/set/UnionSetTest.java (-3 / +3 lines)
20	import org.eclipse.core.databinding.observable.set.IObservableSet;	20	import org.eclipse.core.databinding.observable.set.IObservableSet;
21	import org.eclipse.core.databinding.observable.set.UnionSet;	21	import org.eclipse.core.databinding.observable.set.UnionSet;
22	import org.eclipse.core.databinding.observable.set.WritableSet;	22	import org.eclipse.core.databinding.observable.set.WritableSet;
23	import org.eclipse.jface.conformance.databinding.AbstractObservableCollectionContractDelegate;	23	import org.eclipse.jface.databinding.conformance.ObservableCollectionContractTest;
24	import org.eclipse.jface.conformance.databinding.ObservableCollectionContractTest;	24	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableCollectionContractDelegate;
25	import org.eclipse.jface.conformance.databinding.SuiteBuilder;	25	import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
26		26
27	/**	27	/**
28	*/	28	*/

Lines 23-31 Link Here

(-)src/org/eclipse/core/tests/databinding/observable/set/AbstractObservableSetTest.java (-3 / +3 lines)
23	import org.eclipse.core.databinding.observable.Realm;	23	import org.eclipse.core.databinding.observable.Realm;
24	import org.eclipse.core.databinding.observable.set.AbstractObservableSet;	24	import org.eclipse.core.databinding.observable.set.AbstractObservableSet;
25	import org.eclipse.core.databinding.observable.set.SetDiff;	25	import org.eclipse.core.databinding.observable.set.SetDiff;
26	import org.eclipse.jface.conformance.databinding.AbstractObservableCollectionContractDelegate;	26	import org.eclipse.jface.databinding.conformance.ObservableCollectionContractTest;
27	import org.eclipse.jface.conformance.databinding.ObservableCollectionContractTest;	27	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableCollectionContractDelegate;
28	import org.eclipse.jface.conformance.databinding.SuiteBuilder;	28	import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
29		29
30	/**	30	/**
31	*/	31	*/

Lines 24-32 Link Here

(-)src/org/eclipse/core/tests/databinding/observable/set/ObservableSetTest.java (-3 / +3 lines)
24	import org.eclipse.core.databinding.observable.set.IObservableSet;	24	import org.eclipse.core.databinding.observable.set.IObservableSet;
25	import org.eclipse.core.databinding.observable.set.ObservableSet;	25	import org.eclipse.core.databinding.observable.set.ObservableSet;
26	import org.eclipse.core.databinding.observable.set.SetDiff;	26	import org.eclipse.core.databinding.observable.set.SetDiff;
27	import org.eclipse.jface.conformance.databinding.AbstractObservableCollectionContractDelegate;	27	import org.eclipse.jface.databinding.conformance.ObservableCollectionContractTest;
28	import org.eclipse.jface.conformance.databinding.ObservableCollectionContractTest;	28	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableCollectionContractDelegate;
29	import org.eclipse.jface.conformance.databinding.SuiteBuilder;	29	import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
30		30
31	/**	31	/**
32	* @since 1.1	32	* @since 1.1

Lines 19-28 Link Here

(-)src/org/eclipse/core/tests/databinding/observable/set/WritableSetTest.java (-4 / +4 lines)
19	import org.eclipse.core.databinding.observable.Realm;	19	import org.eclipse.core.databinding.observable.Realm;
20	import org.eclipse.core.databinding.observable.set.IObservableSet;	20	import org.eclipse.core.databinding.observable.set.IObservableSet;
21	import org.eclipse.core.databinding.observable.set.WritableSet;	21	import org.eclipse.core.databinding.observable.set.WritableSet;
22	import org.eclipse.jface.conformance.databinding.AbstractObservableCollectionContractDelegate;	22	import org.eclipse.jface.databinding.conformance.MutableObservableSetContractTest;
23	import org.eclipse.jface.conformance.databinding.MutableObservableSetContractTest;	23	import org.eclipse.jface.databinding.conformance.ObservableCollectionContractTest;
24	import org.eclipse.jface.conformance.databinding.ObservableCollectionContractTest;	24	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableCollectionContractDelegate;
25	import org.eclipse.jface.conformance.databinding.SuiteBuilder;	25	import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
26	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;	26	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
27		27
28	/**	28	/**

Lines 14-22 Link Here

(-)src/org/eclipse/jface/tests/internal/databinding/internal/viewers/SelectionProviderSingleSelectionObservableValueTest.java (-1 / +1 lines)
14		14
15	import junit.framework.TestCase;	15	import junit.framework.TestCase;
16		16
		17	import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;
17	import org.eclipse.jface.databinding.swt.SWTObservables;	18	import org.eclipse.jface.databinding.swt.SWTObservables;
18	import org.eclipse.jface.internal.databinding.internal.viewers.SelectionProviderSingleSelectionObservableValue;	19	import org.eclipse.jface.internal.databinding.internal.viewers.SelectionProviderSingleSelectionObservableValue;
19	import org.eclipse.jface.tests.databinding.EventTrackers.ValueChangeEventTracker;
20	import org.eclipse.jface.viewers.ISelectionProvider;	20	import org.eclipse.jface.viewers.ISelectionProvider;
21	import org.eclipse.jface.viewers.IStructuredContentProvider;	21	import org.eclipse.jface.viewers.IStructuredContentProvider;
22	import org.eclipse.jface.viewers.StructuredSelection;	22	import org.eclipse.jface.viewers.StructuredSelection;

Lines 14-22 Link Here

(-)src/org/eclipse/jface/tests/internal/databinding/internal/viewers/SelectionProviderMultiSelectionObservableListTest.java (-1 / +1 lines)
14	import junit.framework.TestCase;	14	import junit.framework.TestCase;
15		15
16	import org.eclipse.core.databinding.observable.list.ListDiffEntry;	16	import org.eclipse.core.databinding.observable.list.ListDiffEntry;
		17	import org.eclipse.jface.databinding.conformance.util.ListChangeEventTracker;
17	import org.eclipse.jface.databinding.swt.SWTObservables;	18	import org.eclipse.jface.databinding.swt.SWTObservables;
18	import org.eclipse.jface.internal.databinding.internal.viewers.SelectionProviderMultipleSelectionObservableList;	19	import org.eclipse.jface.internal.databinding.internal.viewers.SelectionProviderMultipleSelectionObservableList;
19	import org.eclipse.jface.tests.databinding.EventTrackers.ListChangeEventTracker;
20	import org.eclipse.jface.viewers.ISelectionProvider;	20	import org.eclipse.jface.viewers.ISelectionProvider;
21	import org.eclipse.jface.viewers.IStructuredContentProvider;	21	import org.eclipse.jface.viewers.IStructuredContentProvider;
22	import org.eclipse.jface.viewers.IStructuredSelection;	22	import org.eclipse.jface.viewers.IStructuredSelection;




import org.eclipse.core.databinding.observable.IStaleListener;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.StaleEvent;
import org.eclipse.jface.databinding.conformance.ObservableContractTest;
import org.eclipse.jface.databinding.conformance.ObservableStaleContractTest;
import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableContractDelegate;
import org.eclipse.jface.databinding.conformance.util.ChangeEventTracker;
import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
import org.eclipse.jface.databinding.conformance.util.RealmTester;
import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
import org.eclipse.jface.tests.databinding.RealmTester;
import org.eclipse.jface.tests.databinding.EventTrackers.ChangeEventTracker;
import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;

/**
 * Tests for AbstractObservable.

Lines 14-21 Link Here

(-)src/org/eclipse/core/tests/databinding/observable/RealmTest.java (-2 / +2 lines)
14	import junit.framework.TestCase;	14	import junit.framework.TestCase;
15		15
16	import org.eclipse.core.databinding.observable.Realm;	16	import org.eclipse.core.databinding.observable.Realm;
17	import org.eclipse.jface.tests.databinding.RealmTester;	17	import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
18	import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;	18	import org.eclipse.jface.databinding.conformance.util.RealmTester;
19		19
20	/**	20	/**
21	* @since 3.2	21	* @since 3.2

Lines 26-34 Link Here

(-)src/org/eclipse/core/tests/internal/databinding/internal/beans/JavaBeanObservableValueTest.java (-3 / +3 lines)
26	import org.eclipse.core.databinding.observable.value.ComputedValue;	26	import org.eclipse.core.databinding.observable.value.ComputedValue;
27	import org.eclipse.core.databinding.observable.value.IObservableValue;	27	import org.eclipse.core.databinding.observable.value.IObservableValue;
28	import org.eclipse.core.internal.databinding.internal.beans.JavaBeanObservableValue;	28	import org.eclipse.core.internal.databinding.internal.beans.JavaBeanObservableValue;
29	import org.eclipse.jface.conformance.databinding.AbstractObservableValueContractDelegate;	29	import org.eclipse.jface.databinding.conformance.ObservableValueContractTest;
30	import org.eclipse.jface.conformance.databinding.ObservableValueContractTest;	30	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
31	import org.eclipse.jface.conformance.databinding.SuiteBuilder;	31	import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
32	import org.eclipse.jface.examples.databinding.model.SimplePerson;	32	import org.eclipse.jface.examples.databinding.model.SimplePerson;
33	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;	33	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
34		34

Lines 22-30 Link Here

(-)src/org/eclipse/core/tests/internal/databinding/internal/beans/JavaBeanObservableArrayBasedListTest.java (-1 / +1 lines)
22	import org.eclipse.core.databinding.observable.list.ListChangeEvent;	22	import org.eclipse.core.databinding.observable.list.ListChangeEvent;
23	import org.eclipse.core.databinding.observable.list.ListDiffEntry;	23	import org.eclipse.core.databinding.observable.list.ListDiffEntry;
24	import org.eclipse.core.internal.databinding.internal.beans.JavaBeanObservableList;	24	import org.eclipse.core.internal.databinding.internal.beans.JavaBeanObservableList;
		25	import org.eclipse.jface.databinding.conformance.util.ListChangeEventTracker;
25	import org.eclipse.jface.databinding.swt.SWTObservables;	26	import org.eclipse.jface.databinding.swt.SWTObservables;
26	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;	27	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
27	import org.eclipse.jface.tests.databinding.EventTrackers.ListChangeEventTracker;
28	import org.eclipse.swt.widgets.Display;	28	import org.eclipse.swt.widgets.Display;
29		29
30	/**	30	/**

Lines 22-30 Link Here

(-)src/org/eclipse/core/tests/internal/databinding/internal/beans/JavaBeanObservableListTest.java (-1 / +1 lines)
22	import org.eclipse.core.databinding.observable.list.ListChangeEvent;	22	import org.eclipse.core.databinding.observable.list.ListChangeEvent;
23	import org.eclipse.core.databinding.observable.list.ListDiffEntry;	23	import org.eclipse.core.databinding.observable.list.ListDiffEntry;
24	import org.eclipse.core.internal.databinding.internal.beans.JavaBeanObservableList;	24	import org.eclipse.core.internal.databinding.internal.beans.JavaBeanObservableList;
		25	import org.eclipse.jface.databinding.conformance.util.ListChangeEventTracker;
25	import org.eclipse.jface.databinding.swt.SWTObservables;	26	import org.eclipse.jface.databinding.swt.SWTObservables;
26	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;	27	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
27	import org.eclipse.jface.tests.databinding.EventTrackers.ListChangeEventTracker;
28	import org.eclipse.swt.widgets.Display;	28	import org.eclipse.swt.widgets.Display;
29		29
30	/**	30	/**

Lines 14-19 Link Here

(-)src/org/eclipse/jface/tests/databinding/AbstractDefaultRealmTestCase.java (+1 lines)
14	import junit.framework.TestCase;	14	import junit.framework.TestCase;
15		15
16	import org.eclipse.core.databinding.observable.Realm;	16	import org.eclipse.core.databinding.observable.Realm;
		17	import org.eclipse.jface.databinding.conformance.util.RealmTester;
17	import org.eclipse.jface.databinding.swt.SWTObservables;	18	import org.eclipse.jface.databinding.swt.SWTObservables;
18	import org.eclipse.swt.widgets.Display;	19	import org.eclipse.swt.widgets.Display;
19		20




/*******************************************************************************
 * Copyright (c) 2006 Brad Reynolds and others.
 * 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:
 *     Brad Reynolds - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.tests.databinding;

import junit.framework.Assert;

import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.runtime.AssertionFailedException;

/**
 * Aids in the testing of Realms.
 * 
 * @since 3.2
 */
public class RealmTester {

	/**
	 * Sets the default realm without using Realm.runWithDefault() for testing
	 * purposes.
	 * 
	 * @param realm
	 */
	public static void setDefault(Realm realm) {
		CurrentRealm.setDefault(realm);
	}

	/**
	 * Runs the provided <code>runnable</code> when the realm is both current
	 * and not current. It checks for AssertionFailedExceptions and if an
	 * exception occurs or doesn't occur as expected the test fails. The realm
	 * of an observable created before the method was invoked must be of type
	 * {@link CurrentRealm}. The default realm during the runnable invocation
	 * is set to an instance of {@link CurrentRealm} when the runnable is
	 * invoked.
	 * 
	 * @param runnable
	 */
	public static void exerciseCurrent(Runnable runnable) {
		CurrentRealm previousRealm = (CurrentRealm) Realm.getDefault();
		CurrentRealm realm = new CurrentRealm();
		setDefault(realm);

		try {
			realm.setCurrent(true);
			if (previousRealm != null) {
				previousRealm.setCurrent(true);
			}

			try {
				runnable.run();
			} catch (AssertionFailedException e) {
				Assert
						.fail("Correct realm, exception should not have been thrown");
			}

			realm.setCurrent(false);
			if (previousRealm != null) {
				previousRealm.setCurrent(false);
			}

			try {
				runnable.run();
				Assert
						.fail("Incorrect realm, exception should have been thrown");
			} catch (AssertionFailedException e) {
			}
		} finally {
			setDefault(previousRealm);
		}
	}

	/**
	 * Runs the provided <code>runnable</code> when the realm is both current
	 * and not current. It checks for AssertionFailedExceptions and if an
	 * exception occurs or doesn't occur as expected the test fails.
	 * 
	 * @param runnable
	 * @param realm
	 */
	public static void exerciseCurrent(Runnable runnable, CurrentRealm realm) {
		realm.setCurrent(true);

		try {
			runnable.run();
		} catch (AssertionFailedException e) {
			Assert.fail("Correct realm, exception should not have been thrown");
		}

		realm.setCurrent(false);

		try {
			runnable.run();
			Assert.fail("Incorrect realm, exception should have been thrown");
		} catch (AssertionFailedException e) {
		}
	}

	/**
	 * Realm that will delegate to another for all operations except calls to
	 * {@link #isCurrent()}. The current status can be set by the consumer to
	 * enable testing of realm checks.
	 * 
	 * @since 3.2
	 */
	public static class DelegatingRealm extends CurrentRealm {
		private Realm realm;

		public DelegatingRealm(Realm realm) {
			this.realm = realm;
		}

		protected void syncExec(Runnable runnable) {
			realm.exec(runnable);
		}

		public void asyncExec(Runnable runnable) {
			realm.asyncExec(runnable);
		}
	}

	/**
	 * Allows for the toggling of the current status of the realm. The
	 * asyncExec(...) implementations do nothing.
	 * 
	 * @since 3.2
	 */
	public static class CurrentRealm extends Realm {
		private boolean current;

		public CurrentRealm() {
			this(false);
		}

		public CurrentRealm(boolean current) {
			this.current = current;
		}

		public boolean isCurrent() {
			return current;
		}

		public void setCurrent(boolean current) {
			this.current = current;
		}

		protected void syncExec(Runnable runnable) {
			super.syncExec(runnable);
		}

		public void asyncExec(Runnable runnable) {
			throw new UnsupportedOperationException(
					"CurrentRealm does not support asyncExec(Runnable).");
		}

		protected static Realm setDefault(Realm realm) {
			return Realm.setDefault(realm);
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.tests.databinding;

import java.util.List;

import org.eclipse.core.databinding.observable.ChangeEvent;
import org.eclipse.core.databinding.observable.IChangeListener;
import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.list.IListChangeListener;
import org.eclipse.core.databinding.observable.list.ListChangeEvent;
import org.eclipse.core.databinding.observable.map.IMapChangeListener;
import org.eclipse.core.databinding.observable.map.MapChangeEvent;
import org.eclipse.core.databinding.observable.set.ISetChangeListener;
import org.eclipse.core.databinding.observable.set.SetChangeEvent;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.observable.value.IValueChangeListener;
import org.eclipse.core.databinding.observable.value.ValueChangeEvent;

/**
 * Implementations of change listeners that keep track of the number of times an
 * event fires.
 * 
 * @since 1.1
 */
public class EventTrackers {
	public static class ChangeEventTracker implements IChangeListener {
		public int count;

		public ChangeEvent event;

		/**
		 * Queue that the listener will add itself too when it is notified of an
		 * event. Used to determine order of notifications of listeners.
		 */
		public final List notificationQueue;

		public ChangeEventTracker() {
			notificationQueue = null;
		}

		public ChangeEventTracker(List notificationQueue) {
			this.notificationQueue = notificationQueue;
		}

		public void handleChange(ChangeEvent event) {
			count++;
			this.event = event;
			if (notificationQueue != null) {
				notificationQueue.add(this);
			}
		}
		
		/**
		 * Convenience method to register the listener on an observable allowing for one line setup.
		 * <pre><code>
		 * ChangeEventTracker listener = new ChangeEventTracker().register(observable);
		 * </code></pre>
		 * 
		 * @param observable
		 * @return
		 */
		public ChangeEventTracker register(IObservable observable) {
			observable.addChangeListener(this);
			return this;
		}
	}

	public static class ValueChangeEventTracker implements IValueChangeListener {
		public int count;

		public ValueChangeEvent event;

		public ValueChangeEventTracker() {
		}

		public void handleValueChange(ValueChangeEvent event) {
			count++;
			this.event = event;
		}
		
		/**
		 * Convenience method to register the listener on an observable allowing for one line setup.
		 * <pre><code>
		 * ValueChangeEventTracker listener = new ValueChangeEventTracker().register(observable);
		 * </code></pre>
		 * 
		 * @param observable
		 * @return
		 */
		public ValueChangeEventTracker register(IObservableValue observable) {
			observable.addValueChangeListener(this);
			return this;
		}
	}

	public static class MapChangeEventTracker implements IMapChangeListener {
		public int count;

		public MapChangeEvent event;

		public MapChangeEventTracker() {
		}

		public void handleMapChange(MapChangeEvent event) {
			count++;
			this.event = event;
		}
	}

	public static class ListChangeEventTracker implements IListChangeListener {
		public int count;

		public ListChangeEvent event;
		
		/**
		 * Queue that the listener will add itself too when it is notified of an
		 * event. Used to determine order of notifications of listeners.
		 */
		public final List notificationQueue;

		public ListChangeEventTracker() {
			notificationQueue = null;
		}
		
		public ListChangeEventTracker(List notificationQueue) {
			this.notificationQueue = notificationQueue;
		}

		public void handleListChange(ListChangeEvent event) {
			count++;
			this.event = event;
			if (notificationQueue != null) {
				notificationQueue.add(this);
			}
		}
	}
	
	public static class SetChangeEventTracker implements ISetChangeListener {
		public int count;

		public SetChangeEvent event;
		
		/**
		 * Queue that the listener will add itself too when it is notified of an
		 * event. Used to determine order of notifications of listeners.
		 */
		public final List notificationQueue;

		public SetChangeEventTracker() {
			notificationQueue = null;
		}
		
		public SetChangeEventTracker(List notificationQueue) {
			this.notificationQueue = notificationQueue;
		}

		public void handleSetChange(SetChangeEvent event) {
			count++;
			this.event = event;
			if (notificationQueue != null) {
				notificationQueue.add(this);
			}
		}
	}
}

Lines 29-37 Link Here

(-)src/org/eclipse/core/tests/databinding/DatabindingContextTest.java (-2 / +2 lines)
29	import org.eclipse.core.databinding.validation.IValidator;	29	import org.eclipse.core.databinding.validation.IValidator;
30	import org.eclipse.core.databinding.validation.ValidationStatus;	30	import org.eclipse.core.databinding.validation.ValidationStatus;
31	import org.eclipse.core.runtime.IStatus;	31	import org.eclipse.core.runtime.IStatus;
		32	import org.eclipse.jface.databinding.conformance.util.ChangeEventTracker;
		33	import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;
32	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;	34	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
33	import org.eclipse.jface.tests.databinding.EventTrackers.ChangeEventTracker;
34	import org.eclipse.jface.tests.databinding.EventTrackers.ValueChangeEventTracker;
35		35
36	public class DatabindingContextTest extends AbstractDefaultRealmTestCase {	36	public class DatabindingContextTest extends AbstractDefaultRealmTestCase {
37	private DataBindingContext dbc;	37	private DataBindingContext dbc;

Lines 16-23 Link Here

(-)src/org/eclipse/core/tests/databinding/observable/value/AbstractObservableValueTest.java (-2 / +2 lines)
16	import org.eclipse.core.databinding.observable.Realm;	16	import org.eclipse.core.databinding.observable.Realm;
17	import org.eclipse.core.databinding.observable.value.AbstractObservableValue;	17	import org.eclipse.core.databinding.observable.value.AbstractObservableValue;
18	import org.eclipse.core.databinding.observable.value.ValueDiff;	18	import org.eclipse.core.databinding.observable.value.ValueDiff;
19	import org.eclipse.jface.tests.databinding.RealmTester;	19	import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
20	import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;	20	import org.eclipse.jface.databinding.conformance.util.RealmTester;
21		21
22	/**	22	/**
23	* @since 3.2	23	* @since 3.2

Lines 18-27 Link Here

(-)src/org/eclipse/core/tests/databinding/observable/value/WritableValueTest.java (-4 / +4 lines)
18	import org.eclipse.core.databinding.observable.Realm;	18	import org.eclipse.core.databinding.observable.Realm;
19	import org.eclipse.core.databinding.observable.value.IObservableValue;	19	import org.eclipse.core.databinding.observable.value.IObservableValue;
20	import org.eclipse.core.databinding.observable.value.WritableValue;	20	import org.eclipse.core.databinding.observable.value.WritableValue;
21	import org.eclipse.jface.conformance.databinding.AbstractObservableValueContractDelegate;	21	import org.eclipse.jface.databinding.conformance.MutableObservableValueContractTest;
22	import org.eclipse.jface.conformance.databinding.MutableObservableValueContractTest;	22	import org.eclipse.jface.databinding.conformance.ObservableValueContractTest;
23	import org.eclipse.jface.conformance.databinding.ObservableValueContractTest;	23	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
24	import org.eclipse.jface.conformance.databinding.SuiteBuilder;	24	import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
25	import org.eclipse.jface.databinding.swt.SWTObservables;	25	import org.eclipse.jface.databinding.swt.SWTObservables;
26	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;	26	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
27	import org.eclipse.swt.widgets.Display;	27	import org.eclipse.swt.widgets.Display;

Lines 16-23 Link Here

(-)src/org/eclipse/core/tests/databinding/observable/value/AbstractVetoableValueTest.java (-2 / +2 lines)
16	import org.eclipse.core.databinding.observable.Realm;	16	import org.eclipse.core.databinding.observable.Realm;
17	import org.eclipse.core.databinding.observable.value.AbstractVetoableValue;	17	import org.eclipse.core.databinding.observable.value.AbstractVetoableValue;
18	import org.eclipse.core.databinding.observable.value.ValueDiff;	18	import org.eclipse.core.databinding.observable.value.ValueDiff;
19	import org.eclipse.jface.tests.databinding.RealmTester;	19	import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
20	import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;	20	import org.eclipse.jface.databinding.conformance.util.RealmTester;
21		21
22	/**	22	/**
23	* @since 3.2	23	* @since 3.2

Lines 14-19 Link Here

(-)META-INF/MANIFEST.MF (-1 / +2 lines)
14	org.eclipse.core.runtime,	14	org.eclipse.core.runtime,
15	org.eclipse.jface.examples.databinding,	15	org.eclipse.jface.examples.databinding,
16	org.eclipse.core.databinding.beans,	16	org.eclipse.core.databinding.beans,
17	org.eclipse.jface.databinding	17	org.eclipse.jface.databinding,
		18	org.eclipse.jface.tests.databinding.conformance
18	Import-Package: com.ibm.icu.text	19	Import-Package: com.ibm.icu.text
19		20

Lines 17-25 Link Here

(-)src/org/eclipse/jface/tests/databinding/scenarios/ScenariosTestCase.java (-1 / +1 lines)
17		17
18	import org.eclipse.core.databinding.DataBindingContext;	18	import org.eclipse.core.databinding.DataBindingContext;
19	import org.eclipse.core.databinding.observable.Realm;	19	import org.eclipse.core.databinding.observable.Realm;
		20	import org.eclipse.jface.databinding.conformance.util.RealmTester;
20	import org.eclipse.jface.databinding.swt.SWTObservables;	21	import org.eclipse.jface.databinding.swt.SWTObservables;
21	import org.eclipse.jface.examples.databinding.model.SampleData;	22	import org.eclipse.jface.examples.databinding.model.SampleData;
22	import org.eclipse.jface.tests.databinding.RealmTester;
23	import org.eclipse.swt.SWT;	23	import org.eclipse.swt.SWT;
24	import org.eclipse.swt.layout.FillLayout;	24	import org.eclipse.swt.layout.FillLayout;
25	import org.eclipse.swt.widgets.Button;	25	import org.eclipse.swt.widgets.Button;

Return to bug 182059

Removed Link Here

(-)src/org/eclipse/jface/conformance/databinding/AbstractObservableValueContractDelegate.java (-49 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 Brad Reynolds and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Brad Reynolds - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.jface.conformance.databinding;
13
14	import org.eclipse.core.databinding.observable.IObservable;
15	import org.eclipse.core.databinding.observable.Realm;
16	import org.eclipse.core.databinding.observable.value.IObservableValue;
17
18	/**
19	* Abstract implementation of {@link IObservableValueContractDelegate}.
20	*
21	* @since 1.1
22	*/
23	public abstract class AbstractObservableValueContractDelegate extends
24	AbstractObservableContractDelegate implements
25	IObservableValueContractDelegate {
26
27	/**
28	* Invokes {@link #createObservableValue(Realm)}.
29	*/
30	public final IObservable createObservable(Realm realm) {
31	return createObservableValue(realm);
32	}
33
34	/**
35	* Default implementation returns <code>null</code>.
36	*/
37	public Object getValueType(IObservableValue observable) {
38	// no op
39	return null;
40	}
41
42	/**
43	* Default implementation returns <code>null</code>.
44	*/
45	public Object createValue(IObservableValue observable) {
46	//no op
47	return null;
48	}
49	}

Removed Link Here

(-)src/org/eclipse/jface/conformance/databinding/ObservableListContractTest.java (-108 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.jface.conformance.databinding;
13
14	import org.eclipse.core.databinding.observable.list.IObservableList;
15	import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;
16
17	/**
18	* Tests for IObservableList that don't require mutating the collection.
19	* <p>
20	* This class is experimental and can change at any time. It is recommended to
21	* not subclass or assume the test names will not change. The only API that is
22	* guaranteed to not change are the constructors. The tests will remain public
23	* and not final in order to allow for consumers to turn off a test if needed by
24	* subclassing.
25	* </p>
26	*
27	* @since 3.2
28	*/
29	public class ObservableListContractTest extends
30	ObservableCollectionContractTest {
31	private IObservableList list;
32
33	private IObservableCollectionContractDelegate delegate;
34
35	/**
36	* @param delegate
37	*/
38	public ObservableListContractTest(
39	IObservableCollectionContractDelegate delegate) {
40	super(delegate);
41	this.delegate = delegate;
42	}
43
44	public ObservableListContractTest(String testName,
45	IObservableCollectionContractDelegate delegate) {
46	super(testName, delegate);
47	this.delegate = delegate;
48	}
49
50	protected void setUp() throws Exception {
51	super.setUp();
52
53	list = (IObservableList) getObservable();
54	}
55
56	public void testListIterator_GetterCalled() throws Exception {
57	assertGetterCalled(new Runnable() {
58	public void run() {
59	list.listIterator();
60	}
61	}, "List.listIterator()", list);
62	}
63
64	public void testGet_GetterCalled() throws Exception {
65	list = (IObservableList) delegate.createObservableCollection(new CurrentRealm(true), 1);
66	assertGetterCalled(new Runnable() {
67	public void run() {
68	list.get(0);
69	}
70	}, "List.get(int)", list);
71	}
72
73	public void testIndexOf_GetterCalled() throws Exception {
74	assertGetterCalled(new Runnable() {
75	public void run() {
76	list.indexOf(delegate.createElement(list));
77	}
78	}, "List.indexOf(int)", list);
79	}
80
81	public void testLastIndexOf_GetterCalled() throws Exception {
82	assertGetterCalled(new Runnable() {
83	public void run() {
84	list.lastIndexOf(delegate.createElement(list));
85	}
86	}, "List.lastIndexOf(Object)", list);
87	}
88
89	public void testListIteratorAtIndex_GetterCalled() throws Exception {
90	// Create a new list instead of adding an item because the list might
91	// not be mutable
92	list = (IObservableList) delegate.createObservableCollection(new CurrentRealm(true), 1);
93	assertGetterCalled(new Runnable() {
94	public void run() {
95	list.listIterator(0);
96	}
97	}, "List.listIterator(int)", list);
98	}
99
100	public void testSubList_GetterCalled() throws Exception {
101	list = (IObservableList) delegate.createObservableCollection(new CurrentRealm(true), 1);
102	assertGetterCalled(new Runnable() {
103	public void run() {
104	list.subList(0, 1);
105	}
106	}, "List.subList(int, int)", list);
107	}
108	}

Lines 12-17 Link Here

(-)src/org/eclipse/jface/tests/databinding/swt/SWTObservablesTest.java (-1 / +1 lines)
12	package org.eclipse.jface.tests.databinding.swt;	12	package org.eclipse.jface.tests.databinding.swt;
13		13
14	import org.eclipse.core.databinding.observable.list.IObservableList;	14	import org.eclipse.core.databinding.observable.list.IObservableList;
		15	import org.eclipse.jface.databinding.conformance.util.RealmTester;
15	import org.eclipse.jface.databinding.swt.ISWTObservableValue;	16	import org.eclipse.jface.databinding.swt.ISWTObservableValue;
16	import org.eclipse.jface.databinding.swt.SWTObservables;	17	import org.eclipse.jface.databinding.swt.SWTObservables;
17	import org.eclipse.jface.internal.databinding.internal.swt.ButtonObservableValue;	18	import org.eclipse.jface.internal.databinding.internal.swt.ButtonObservableValue;
Lines 30-36 Link Here
30	import org.eclipse.jface.internal.databinding.internal.swt.TextEditableObservableValue;	31	import org.eclipse.jface.internal.databinding.internal.swt.TextEditableObservableValue;
31	import org.eclipse.jface.internal.databinding.internal.swt.TextObservableValue;	32	import org.eclipse.jface.internal.databinding.internal.swt.TextObservableValue;
32	import org.eclipse.jface.tests.databinding.AbstractSWTTestCase;	33	import org.eclipse.jface.tests.databinding.AbstractSWTTestCase;
33	import org.eclipse.jface.tests.databinding.RealmTester;
34	import org.eclipse.swt.SWT;	34	import org.eclipse.swt.SWT;
35	import org.eclipse.swt.custom.CCombo;	35	import org.eclipse.swt.custom.CCombo;
36	import org.eclipse.swt.custom.CLabel;	36	import org.eclipse.swt.custom.CLabel;

Removed Link Here

(-)src/org/eclipse/jface/tests/databinding/RealmTester.java (-168 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 Brad Reynolds and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Brad Reynolds - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.jface.tests.databinding;
13
14	import junit.framework.Assert;
15
16	import org.eclipse.core.databinding.observable.Realm;
17	import org.eclipse.core.runtime.AssertionFailedException;
18
19	/**
20	* Aids in the testing of Realms.
21	*
22	* @since 3.2
23	*/
24	public class RealmTester {
25
26	/**
27	* Sets the default realm without using Realm.runWithDefault() for testing
28	* purposes.
29	*
30	* @param realm
31	*/
32	public static void setDefault(Realm realm) {
33	CurrentRealm.setDefault(realm);
34	}
35
36	/**
37	* Runs the provided <code>runnable</code> when the realm is both current
38	* and not current. It checks for AssertionFailedExceptions and if an
39	* exception occurs or doesn't occur as expected the test fails. The realm
40	* of an observable created before the method was invoked must be of type
41	* {@link CurrentRealm}. The default realm during the runnable invocation
42	* is set to an instance of {@link CurrentRealm} when the runnable is
43	* invoked.
44	*
45	* @param runnable
46	*/
47	public static void exerciseCurrent(Runnable runnable) {
48	CurrentRealm previousRealm = (CurrentRealm) Realm.getDefault();
49	CurrentRealm realm = new CurrentRealm();
50	setDefault(realm);
51
52	try {
53	realm.setCurrent(true);
54	if (previousRealm != null) {
55	previousRealm.setCurrent(true);
56	}
57
58	try {
59	runnable.run();
60	} catch (AssertionFailedException e) {
61	Assert
62	.fail("Correct realm, exception should not have been thrown");
63	}
64
65	realm.setCurrent(false);
66	if (previousRealm != null) {
67	previousRealm.setCurrent(false);
68	}
69
70	try {
71	runnable.run();
72	Assert
73	.fail("Incorrect realm, exception should have been thrown");
74	} catch (AssertionFailedException e) {
75	}
76	} finally {
77	setDefault(previousRealm);
78	}
79	}
80
81	/**
82	* Runs the provided <code>runnable</code> when the realm is both current
83	* and not current. It checks for AssertionFailedExceptions and if an
84	* exception occurs or doesn't occur as expected the test fails.
85	*
86	* @param runnable
87	* @param realm
88	*/
89	public static void exerciseCurrent(Runnable runnable, CurrentRealm realm) {
90	realm.setCurrent(true);
91
92	try {
93	runnable.run();
94	} catch (AssertionFailedException e) {
95	Assert.fail("Correct realm, exception should not have been thrown");
96	}
97
98	realm.setCurrent(false);
99
100	try {
101	runnable.run();
102	Assert.fail("Incorrect realm, exception should have been thrown");
103	} catch (AssertionFailedException e) {
104	}
105	}
106
107	/**
108	* Realm that will delegate to another for all operations except calls to
109	* {@link #isCurrent()}. The current status can be set by the consumer to
110	* enable testing of realm checks.
111	*
112	* @since 3.2
113	*/
114	public static class DelegatingRealm extends CurrentRealm {
115	private Realm realm;
116
117	public DelegatingRealm(Realm realm) {
118	this.realm = realm;
119	}
120
121	protected void syncExec(Runnable runnable) {
122	realm.exec(runnable);
123	}
124
125	public void asyncExec(Runnable runnable) {
126	realm.asyncExec(runnable);
127	}
128	}
129
130	/**
131	* Allows for the toggling of the current status of the realm. The
132	* asyncExec(...) implementations do nothing.
133	*
134	* @since 3.2
135	*/
136	public static class CurrentRealm extends Realm {
137	private boolean current;
138
139	public CurrentRealm() {
140	this(false);
141	}
142
143	public CurrentRealm(boolean current) {
144	this.current = current;
145	}
146
147	public boolean isCurrent() {
148	return current;
149	}
150
151	public void setCurrent(boolean current) {
152	this.current = current;
153	}
154
155	protected void syncExec(Runnable runnable) {
156	super.syncExec(runnable);
157	}
158
159	public void asyncExec(Runnable runnable) {
160	throw new UnsupportedOperationException(
161	"CurrentRealm does not support asyncExec(Runnable).");
162	}
163
164	protected static Realm setDefault(Realm realm) {
165	return Realm.setDefault(realm);
166	}
167	}
168	}