Attachment #78508 for bug #182059

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




###############################################################################
# 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
###############################################################################
pluginName = JFace Data Binding Conformance Tests
providerName = Eclipse.org




/*******************************************************************************
 * 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.databinding.conformance;

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.databinding.conformance.delegate.IObservableCollectionContractDelegate;
import org.eclipse.jface.databinding.conformance.util.ChangeEventTracker;
import org.eclipse.jface.databinding.conformance.util.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));
	}
}




<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
<title>About</title>
</head>
<body lang="EN-US">
<h2>About This Content</h2>
 
<p>June 2, 2006</p>	
<h3>License</h3>

<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
indicated below, the Content is provided to you under the terms and conditions of the
Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>

<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
being redistributed by another party (&quot;Redistributor&quot;) and different terms and conditions may
apply to your use of any object code in the Content.  Check the Redistributor's license that was 
provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
indicated below, the terms and conditions of the EPL still apply to any source code in the Content
and such source code may be obtained at <a href="http://www.eclipse.org">http://www.eclipse.org</a>.</p>

</body>
</html>




/*******************************************************************************
 * 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.databinding.conformance;

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.databinding.conformance.delegate.IObservableCollectionContractDelegate;
import org.eclipse.jface.databinding.conformance.util.ChangeEventTracker;
import org.eclipse.jface.databinding.conformance.util.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 = ListChangeEventTracker.observe(list);

		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.databinding.conformance.swt;

import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.jface.databinding.conformance.MutableObservableValueContractTest;
import org.eclipse.jface.databinding.conformance.delegate.IObservableValueContractDelegate;
import org.eclipse.jface.databinding.conformance.util.DelegatingRealm;
import org.eclipse.jface.databinding.swt.SWTObservables;
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.
	 * @return observable
	 */
	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);
	}
}




Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: %pluginName
Bundle-SymbolicName: org.eclipse.jface.tests.databinding.conformance
Bundle-Version: 1.0.0
Require-Bundle: org.junit,
 org.eclipse.core.databinding,
 org.eclipse.jface.databinding,
 org.eclipse.swt,
 org.eclipse.core.runtime
Bundle-Vendor: %providerName
Bundle-RequiredExecutionEnvironment: J2SE-1.4
Export-Package: org.eclipse.jface.databinding.conformance,
 org.eclipse.jface.databinding.conformance.util




package org.eclipse.jface.databinding.conformance.util;

import java.util.List;

import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.observable.set.ISetChangeListener;
import org.eclipse.core.databinding.observable.set.SetChangeEvent;

public 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 listenerQueue;

	public SetChangeEventTracker() {
		this(null);
	}

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

	public void handleSetChange(SetChangeEvent event) {
		count++;
		this.event = event;
		if (listenerQueue != null) {
			listenerQueue.add(this);
		}
	}
	
	/**
	 * Convenience method to register a new listener.
	 * 
	 * @param observable
	 * @return tracker
	 */
	public static SetChangeEventTracker observe(IObservableSet observable) {
		SetChangeEventTracker tracker = new SetChangeEventTracker();
		observable.addSetChangeListener(tracker);
		return tracker;
	}
}




/*******************************************************************************
 * 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.databinding.conformance.delegate;

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.databinding.conformance;

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.databinding.conformance.delegate.IObservableCollectionContractDelegate;
import org.eclipse.jface.databinding.conformance.util.ChangeEventTracker;
import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
import org.eclipse.jface.databinding.conformance.util.RealmTester;

/**
 * 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 = ChangeEventTracker.observe(collection);
		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 elementNotContained
	 */
	/* 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.databinding.conformance;

import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.jface.databinding.conformance.delegate.IObservableCollectionContractDelegate;
import org.eclipse.jface.databinding.conformance.util.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 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.databinding.conformance;

import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.IStaleListener;
import org.eclipse.core.databinding.observable.StaleEvent;
import org.eclipse.jface.databinding.conformance.delegate.IObservableContractDelegate;

/**
 * @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();
		}
	}

}




package org.eclipse.jface.databinding.conformance.util;

import java.util.List;

import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.observable.value.IValueChangeListener;
import org.eclipse.core.databinding.observable.value.ValueChangeEvent;

/**
 * Listener for tracking the firing of ValueChangeEvents.
 */
public class ValueChangeEventTracker implements IValueChangeListener {
	public int count;

	public ValueChangeEvent event;

	public final List queue;

	public ValueChangeEventTracker() {
		this(null);
	}

	public ValueChangeEventTracker(List queue) {
		this.queue = queue;
	}

	public void handleValueChange(ValueChangeEvent event) {
		count++;
		this.event = event;

		if (queue != null) {
			queue.add(this);
		}
	}

	/**
	 * Convenience method to register a new listener.
	 * 
	 * @param observable
	 * @return tracker
	 */
	public static ValueChangeEventTracker observe(IObservableValue observable) {
		ValueChangeEventTracker tracker = new ValueChangeEventTracker();
		observable.addValueChangeListener(tracker);
		return tracker;
	}
}




package org.eclipse.jface.databinding.conformance.util;

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

/**
 * Allows for the toggling of the current status of the realm. The
 * asyncExec(...) implementations do nothing.
 * 
 * @since 3.2
 */
public 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)."); //$NON-NLS-1$
	}

	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.databinding.conformance;

import junit.framework.TestCase;

import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.jface.databinding.conformance.delegate.IObservableContractDelegate;
import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
import org.eclipse.jface.databinding.conformance.util.RealmTester;

/**
 * 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 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.databinding.conformance;

import java.util.Arrays;

import org.eclipse.core.databinding.observable.IObservableCollection;
import org.eclipse.jface.databinding.conformance.delegate.IObservableCollectionContractDelegate;
import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
import org.eclipse.jface.databinding.conformance.util.RealmTester;

/**
 * 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.databinding.conformance.swt;

import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.jface.databinding.conformance.ObservableValueContractTest;
import org.eclipse.jface.databinding.conformance.delegate.IObservableValueContractDelegate;
import org.eclipse.jface.databinding.conformance.util.DelegatingRealm;
import org.eclipse.jface.databinding.swt.SWTObservables;
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.
	 * @return observable
	 */
	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.databinding.conformance;

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.databinding.conformance.delegate.IObservableValueContractDelegate;
import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
import org.eclipse.jface.databinding.conformance.util.RealmTester;
import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;

/**
 * @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.databinding.conformance.ObservableContractTest#setUp()
	 */
	protected void setUp() throws Exception {
		super.setUp();
		observable = (IObservableValue) getObservable();
	}

	public void testChange_ValueChangeEvent() throws Exception {
		ValueChangeEventTracker listener = ValueChangeEventTracker.observe(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 = ValueChangeEventTracker.observe(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 implements IValueChangeListener {
			Object value;

			public void handleValueChange(ValueChangeEvent event) {
				this.value = event.getObservableValue().getValue();
			}
		}
		
		ValueChangeListener listener = new ValueChangeListener();
		observable.addValueChangeListener(listener);
		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 = ValueChangeEventTracker.observe(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.databinding.conformance.delegate;

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)}.
	 * @param realm 
	 * @return observable
	 */
	public final IObservable createObservable(Realm realm) {
		return createObservableValue(realm);
	}

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




/*******************************************************************************
 * 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.databinding.conformance.util;

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) {
		}
	}
}




package org.eclipse.jface.databinding.conformance.util;

import java.util.List;

import org.eclipse.core.databinding.observable.list.IListChangeListener;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.list.ListChangeEvent;

/**
 * Listener for tracking the firing of ListChangeEvents.
 */
public 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 listenerQueue;

	public ListChangeEventTracker() {
		this(null);
	}

	public ListChangeEventTracker(List listenerQueue) {
		this.listenerQueue = listenerQueue;
	}

	public void handleListChange(ListChangeEvent event) {
		count++;
		this.event = event;
		if (listenerQueue != null) {
			listenerQueue.add(this);
		}
	}
	
	/**
	 * Convenience method to register a new listener.
	 * 
	 * @param observable
	 * @return tracker
	 */
	public static ListChangeEventTracker observe(IObservableList observable) {
		ListChangeEventTracker tracker = new ListChangeEventTracker();
		observable.addListChangeListener(tracker);
		return tracker;
	}
}




/*******************************************************************************
 * 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.databinding.conformance.delegate;

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 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.databinding.conformance;

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.databinding.conformance.delegate.IObservableContractDelegate;
import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
import org.eclipse.jface.databinding.conformance.util.RealmTester;

/**
 * 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.databinding.conformance.delegate;

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);
}




#Sat Sep 15 18:25:36 MDT 2007
eclipse.preferences.version=1
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=disabled
org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.2
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
org.eclipse.jdt.core.compiler.compliance=1.4
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
org.eclipse.jdt.core.compiler.problem.autoboxing=ignore
org.eclipse.jdt.core.compiler.problem.deprecation=warning
org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled
org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled
org.eclipse.jdt.core.compiler.problem.discouragedReference=warning
org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore
org.eclipse.jdt.core.compiler.problem.enumIdentifier=warning
org.eclipse.jdt.core.compiler.problem.fallthroughCase=ignore
org.eclipse.jdt.core.compiler.problem.fatalOptionalError=enabled
org.eclipse.jdt.core.compiler.problem.fieldHiding=ignore
org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning
org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning
org.eclipse.jdt.core.compiler.problem.forbiddenReference=error
org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning
org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning
org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=ignore
org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore
org.eclipse.jdt.core.compiler.problem.localVariableHiding=ignore
org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning
org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=ignore
org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=ignore
org.eclipse.jdt.core.compiler.problem.missingSerialVersion=warning
org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning
org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning
org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=ignore
org.eclipse.jdt.core.compiler.problem.nullReference=ignore
org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning
org.eclipse.jdt.core.compiler.problem.parameterAssignment=ignore
org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=ignore
org.eclipse.jdt.core.compiler.problem.potentialNullReference=ignore
org.eclipse.jdt.core.compiler.problem.rawTypeReference=warning
org.eclipse.jdt.core.compiler.problem.redundantNullCheck=ignore
org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled
org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning
org.eclipse.jdt.core.compiler.problem.suppressWarnings=enabled
org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore
org.eclipse.jdt.core.compiler.problem.typeParameterHiding=warning
org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=warning
org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=ignore
org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=warning
org.eclipse.jdt.core.compiler.problem.unnecessaryElse=ignore
org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=ignore
org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore
org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=ignore
org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled
org.eclipse.jdt.core.compiler.problem.unusedImport=warning
org.eclipse.jdt.core.compiler.problem.unusedLabel=warning
org.eclipse.jdt.core.compiler.problem.unusedLocal=warning
org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore
org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference=enabled
org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled
org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled
org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=warning
org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
org.eclipse.jdt.core.compiler.source=1.3




package org.eclipse.jface.databinding.conformance.util;

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;

/**
 * Listener for tracking the firing of ChangeEvents.
 */
public 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.  Can be null.
	 */
	public final List queue;

	public ChangeEventTracker() {
		queue = null;
	}

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

	public void handleChange(ChangeEvent event) {
		count++;
		this.event = event;
		if (queue != null) {
			queue.add(this);
		}
	}

	/**
	 * Convenience method to register a new listener.
	 * 
	 * @param observable
	 * @return tracker
	 */
	public static ChangeEventTracker observe(IObservable observable) {
		ChangeEventTracker tracker = new ChangeEventTracker();
		observable.addChangeListener(tracker);
		return tracker;
	}
}




/*******************************************************************************
 * 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.databinding.conformance.delegate;

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 IObservableCollectionContractDelegate#createObservableCollection(Realm, int)}.
	 * @param realm 
	 * @return observable
	 */
	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.databinding.conformance.util;

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

import org.eclipse.jface.databinding.conformance.delegate.IObservableContractDelegate;

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 builder
	 */
	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 clazz 
	 * @param parameters
	 * @return constructor
	 */
	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;
		}
	}
}




/*******************************************************************************
 * 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.databinding.conformance;

import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.jface.databinding.conformance.delegate.IObservableValueContractDelegate;
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.ValueChangeEventTracker;

/**
 * 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 = ChangeEventTracker.observe(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 = ValueChangeEventTracker.observe(observable);
		ChangeEventTracker changeListener = ChangeEventTracker.observe(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.databinding.conformance.delegate;

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 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
###############################################################################
bin.includes = .,\
               META-INF/,\
               plugin.properties,\
               about.html
output.databinding.jar = bin/
src.includes = about.html
source.. = src/

Added Link Here

(-).classpath (+7 lines)
1	<?xml version="1.0" encoding="UTF-8"?>
2	<classpath>
3	<classpathentry kind="src" path="src"/>
4	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.4"/>
5	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
6	<classpathentry kind="output" path="bin"/>
7	</classpath>




package org.eclipse.jface.databinding.conformance.util;

import java.util.List;

import org.eclipse.core.databinding.observable.map.IMapChangeListener;
import org.eclipse.core.databinding.observable.map.IObservableMap;
import org.eclipse.core.databinding.observable.map.MapChangeEvent;

/**
 * Listener for tracking the firing of ChangeEvents.
 */
public class MapChangeEventTracker implements IMapChangeListener {
	public int count;

	public MapChangeEvent event;

	public List queue;
	
	public MapChangeEventTracker() {
		this(null);
	}
	
	public MapChangeEventTracker(List queue) {
		this.queue = queue;
	}

	public void handleMapChange(MapChangeEvent event) {
		count++;
		this.event = event;
		
		if (queue != null) {
			queue.add(this);
		}
	}
	
	/**
	 * Convenience method to register a new listener.
	 * 
	 * @param observable
	 * @return tracker
	 */
	public static MapChangeEventTracker observe(IObservableMap observable) {
		MapChangeEventTracker tracker = new MapChangeEventTracker();
		observable.addMapChangeListener(tracker);
		return tracker;
	}
}




package org.eclipse.jface.databinding.conformance.util;

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

/**
 * 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 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);
	}
}




<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
	<name>org.eclipse.jface.tests.databinding.conformance</name>
	<comment></comment>
	<projects>
	</projects>
	<buildSpec>
		<buildCommand>
			<name>org.eclipse.jdt.core.javabuilder</name>
			<arguments>
			</arguments>
		</buildCommand>
		<buildCommand>
			<name>org.eclipse.pde.ManifestBuilder</name>
			<arguments>
			</arguments>
		</buildCommand>
		<buildCommand>
			<name>org.eclipse.pde.SchemaBuilder</name>
			<arguments>
			</arguments>
		</buildCommand>
	</buildSpec>
	<natures>
		<nature>org.eclipse.pde.PluginNature</nature>
		<nature>org.eclipse.jdt.core.javanature</nature>
	</natures>
</projectDescription>




/*******************************************************************************
 * 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 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 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 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/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;

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;




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 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 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 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

Added Link Here

(-)plugin.properties (+12 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	pluginName = JFace Data Binding Conformance Tests
12	providerName = Eclipse.org

Added Link Here

(-)src/org/eclipse/jface/databinding/conformance/MutableObservableSetContractTest.java (+266 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.databinding.conformance;
13
14	import java.util.ArrayList;
15	import java.util.Arrays;
16	import java.util.List;
17	import java.util.Set;
18
19	import org.eclipse.core.databinding.observable.set.IObservableSet;
20	import org.eclipse.jface.databinding.conformance.delegate.IObservableCollectionContractDelegate;
21	import org.eclipse.jface.databinding.conformance.util.ChangeEventTracker;
22	import org.eclipse.jface.databinding.conformance.util.SetChangeEventTracker;
23
24	/**
25	*/
26	public class MutableObservableSetContractTest extends
27	MutableObservableCollectionContractTest {
28	private IObservableCollectionContractDelegate delegate;
29
30	private IObservableSet set;
31
32	public MutableObservableSetContractTest(String testName,
33	IObservableCollectionContractDelegate delegate) {
34	super(testName, delegate);
35	this.delegate = delegate;
36	}
37
38	/**
39	* @param delegate
40	*/
41	public MutableObservableSetContractTest(
42	IObservableCollectionContractDelegate delegate) {
43	super(delegate);
44	}
45
46	protected void setUp() throws Exception {
47	super.setUp();
48	set = (IObservableSet) getObservable();
49	}
50
51	public void testAdd_SetChangeEvent() throws Exception {
52	assertSetChangeEventFired(new Runnable() {
53	public void run() {
54	set.add(delegate.createElement(set));
55	}
56	}, "Set.add(Object)", set);
57	}
58
59	public void testAdd_SetDiffEntry() throws Exception {
60	set.add(delegate.createElement(set));
61	final Object element = delegate.createElement(set);
62
63	assertAddDiffEntry(new Runnable() {
64	public void run() {
65	set.add(element);
66	}
67	}, "Set.add(Object)", set, element);
68	}
69
70	public void testAddAll_SetChangeEvent() throws Exception {
71	assertSetChangeEventFired(new Runnable() {
72	public void run() {
73	set.addAll(Arrays.asList(new Object[] { delegate
74	.createElement(set) }));
75	}
76	}, "Set.addAll(Collection", set);
77	}
78
79	public void testAddAll_SetDiffEntry() throws Exception {
80	final Object element = delegate.createElement(set);
81
82	assertAddDiffEntry(new Runnable() {
83	public void run() {
84	set.addAll(Arrays.asList(new Object[] { element }));
85	}
86	}, "Set.addAll(Collection)", set, element);
87	}
88
89	public void testRemove_SetChangeEvent() throws Exception {
90	final Object element = delegate.createElement(set);
91	set.add(element);
92
93	assertSetChangeEventFired(new Runnable() {
94	public void run() {
95	set.remove(element);
96	}
97	}, "Set.remove(Object)", set);
98	}
99
100	public void testRemove_SetDiffEntry() throws Exception {
101	set.add(delegate.createElement(set));
102	final Object element = delegate.createElement(set);
103	set.add(element);
104
105	assertRemoveDiffEntry(new Runnable() {
106	public void run() {
107	set.remove(element);
108	}
109	}, "Set.remove(Object)", set, element);
110	}
111
112	public void testRemoveAll_SetChangeEvent() throws Exception {
113	final Object element = delegate.createElement(set);
114	set.add(element);
115
116	assertSetChangeEventFired(new Runnable() {
117	public void run() {
118	set.removeAll(Arrays.asList(new Object[] { element }));
119	}
120	}, "Set.removeAll(Collection)", set);
121	}
122
123	public void testRemoveAll_SetDiffEntry() throws Exception {
124	final Object element = delegate.createElement(set);
125	set.add(element);
126
127	assertRemoveDiffEntry(new Runnable() {
128	public void run() {
129	set.removeAll(Arrays.asList(new Object[] { element }));
130	}
131	}, "Set.removeAll(Collection)", set, element);
132	}
133
134	public void testRetainAll_SetChangeEvent() throws Exception {
135	final Object element1 = delegate.createElement(set);
136	set.add(element1);
137	set.add(delegate.createElement(set));
138
139	assertSetChangeEventFired(new Runnable() {
140	public void run() {
141	set.retainAll(Arrays.asList(new Object[] { element1 }));
142	}
143	}, "Set.retainAll(Collection", set);
144	}
145
146	public void testRetainAll_SetDiffEntry() throws Exception {
147	final Object element1 = delegate.createElement(set);
148	set.add(element1);
149	Object element2 = delegate.createElement(set);
150	set.add(delegate.createElement(set));
151
152	assertRemoveDiffEntry(new Runnable() {
153	public void run() {
154	set.retainAll(Arrays.asList(new Object[] { element1 }));
155	}
156	}, "Set.retainAll(Collection)", set, element2);
157	}
158
159	public void testClear_SetChangeEvent() throws Exception {
160	set.add(delegate.createElement(set));
161
162	assertSetChangeEventFired(new Runnable() {
163	public void run() {
164	set.clear();
165	}
166	}, "Set.clear()", set);
167	}
168
169	public void testClear_SetDiffEntry() throws Exception {
170	Object element = delegate.createElement(set);
171	set.add(element);
172
173	assertRemoveDiffEntry(new Runnable() {
174	public void run() {
175	set.clear();
176	}
177	}, "Set.clear()", set, element);
178	}
179
180	/**
181	* Asserts standard behaviors of firing set change events.
182	* <ul>
183	* <li>Event fires once.</li>
184	* <li>Source of the event is the provided <code>set</code>.
185	* <li>The set change event is fired after the change event.</li>
186	* </ul>
187	*
188	* @param runnable
189	* @param methodName
190	* @param set
191	*/
192	private void assertSetChangeEventFired(Runnable runnable,
193	String methodName, IObservableSet set) {
194	List queue = new ArrayList();
195	SetChangeEventTracker setListener = new SetChangeEventTracker(queue);
196	ChangeEventTracker changeListener = new ChangeEventTracker(queue);
197
198	set.addSetChangeListener(setListener);
199	set.addChangeListener(changeListener);
200
201	runnable.run();
202
203	assertEquals(formatFail(methodName + " should fire one SetChangeEvent."), 1,
204	setListener.count);
205	assertEquals(formatFail(methodName
206	+ "'s change event observable should be the created Set."), set,
207	setListener.event.getObservable());
208
209	assertEquals(formatFail("Two notifications should have been received."), 2, queue
210	.size());
211	assertEquals(formatFail("ChangeEvent of " + methodName
212	+ " should have fired before the SetChangeEvent."),
213	changeListener, queue.get(0));
214	assertEquals(formatFail("SetChangeEvent of " + methodName
215	+ " should have fired after the ChangeEvent."), setListener,
216	queue.get(1));
217	}
218
219	/**
220	* Asserts the set diff entry for an add operation.
221	*
222	* @param runnable
223	* @param methodName
224	* @param set
225	* @param element
226	*/
227	private void assertAddDiffEntry(Runnable runnable, String methodName,
228	IObservableSet set, Object element) {
229	SetChangeEventTracker listener = new SetChangeEventTracker();
230	set.addSetChangeListener(listener);
231
232	runnable.run();
233
234	Set entries = listener.event.diff.getAdditions();
235	assertEquals(formatFail(methodName + " should result in one diff entry."), 1,
236	entries.size());
237
238	assertTrue(formatFail(methodName
239	+ " should result in a diff entry that is an addition."),
240	entries.contains(element));
241	}
242
243	/**
244	* Asserts the set diff entry for a remove operation.
245	*
246	* @param runnable
247	* @param methodName
248	* @param set
249	* @param element
250	*/
251	private void assertRemoveDiffEntry(Runnable runnable, String methodName,
252	IObservableSet set, Object element) {
253	SetChangeEventTracker listener = new SetChangeEventTracker();
254	set.addSetChangeListener(listener);
255
256	runnable.run();
257
258	Set entries = listener.event.diff.getRemovals();
259	assertEquals(formatFail(methodName + " should result in one diff entry."), 1,
260	entries.size());
261
262	assertTrue(formatFail(methodName
263	+ " should result in a diff entry that is an addition."),
264	entries.contains(element));
265	}
266	}

Added Link Here

(-)about.html (+28 lines)
1	<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
2	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
3	<html xmlns="http://www.w3.org/1999/xhtml">
4	<head>
5	<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
6	<title>About</title>
7	</head>
8	<body lang="EN-US">
9	<h2>About This Content</h2>
10
11	<p>June 2, 2006</p>
12	<h3>License</h3>
13
14	<p>The Eclipse Foundation makes available all content in this plug-in ("Content"). Unless otherwise
15	indicated below, the Content is provided to you under the terms and conditions of the
16	Eclipse Public License Version 1.0 ("EPL"). A copy of the EPL is available
17	at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
18	For purposes of the EPL, "Program" will mean the Content.</p>
19
20	<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is
21	being redistributed by another party ("Redistributor") and different terms and conditions may
22	apply to your use of any object code in the Content. Check the Redistributor's license that was
23	provided with the Content. If no such license exists, contact the Redistributor. Unless otherwise
24	indicated below, the terms and conditions of the EPL still apply to any source code in the Content
25	and such source code may be obtained at <a href="http://www.eclipse.org">http://www.eclipse.org</a>.</p>
26
27	</body>
28	</html>

Added Link Here

(-)src/org/eclipse/jface/databinding/conformance/MutableObservableListContractTest.java (+493 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.databinding.conformance;
13
14	import java.util.ArrayList;
15	import java.util.Arrays;
16	import java.util.List;
17
18	import org.eclipse.core.databinding.observable.list.IObservableList;
19	import org.eclipse.core.databinding.observable.list.ListDiffEntry;
20	import org.eclipse.jface.databinding.conformance.delegate.IObservableCollectionContractDelegate;
21	import org.eclipse.jface.databinding.conformance.util.ChangeEventTracker;
22	import org.eclipse.jface.databinding.conformance.util.ListChangeEventTracker;
23
24
25	/**
26	* Mutability tests for IObservableList.
27	*
28	* <p>
29	* This class is experimental and can change at any time. It is recommended to
30	* not subclass or assume the test names will not change. The only API that is
31	* guaranteed to not change are the constructors. The tests will remain public
32	* and not final in order to allow for consumers to turn off a test if needed by
33	* subclassing.
34	* </p>
35	*
36	* @since 3.2
37	*/
38	public class MutableObservableListContractTest extends
39	MutableObservableCollectionContractTest {
40	private IObservableCollectionContractDelegate delegate;
41
42	private IObservableList list;
43
44	/**
45	* @param delegate
46	*/
47	public MutableObservableListContractTest(
48	IObservableCollectionContractDelegate delegate) {
49	super(delegate);
50	this.delegate = delegate;
51	}
52
53	public MutableObservableListContractTest(String testName,
54	IObservableCollectionContractDelegate delegate) {
55	super(testName, delegate);
56	this.delegate = delegate;
57	}
58
59	protected void setUp() throws Exception {
60	super.setUp();
61	list = (IObservableList) getObservable();
62	}
63
64	public void testAdd_ListChangeEvent() throws Exception {
65	assertListChangeEventFired(new Runnable() {
66	public void run() {
67	list.add(delegate.createElement(list));
68	}
69	}, "List.add(Object)", list);
70	}
71
72	public void testAdd_ListDiffEntry() throws Exception {
73	list.add(delegate.createElement(list));
74	final Object element = delegate.createElement(list);
75
76	assertAddDiffEntry(new Runnable() {
77	public void run() {
78	list.add(element);
79	}
80	}, "List.add(Object)", list, element, 1);
81	}
82
83	public void testAddAtIndex_ChangeEvent() throws Exception {
84	assertChangeEventFired(new Runnable() {
85	public void run() {
86	list.add(0, delegate.createElement(list));
87	}
88	}, "List.add(int, Object)", list);
89	}
90
91	public void testAddAtIndex_ListChangeEvent() throws Exception {
92	assertListChangeEventFired(new Runnable() {
93	public void run() {
94	list.add(0, delegate.createElement(list));
95	}
96	}, "List.add(int, Object)", list);
97	}
98
99	public void testAddAtIndex_ChangeEventFiredAfterElementIsAdded()
100	throws Exception {
101	final Object element = delegate.createElement(list);
102
103	assertContainsDuringChangeEvent(new Runnable() {
104	public void run() {
105	list.add(0, element);
106	}
107	}, "List.add(int, Collection)", list, element);
108	}
109
110	public void testAddAtIndex_ListDiffEntry() throws Exception {
111	list.add(delegate.createElement(list));
112	final Object element = delegate.createElement(list);
113
114	assertAddDiffEntry(new Runnable() {
115	public void run() {
116	list.add(1, element);
117	}
118	}, "List.add(int, Object)", list, element, 1);
119	}
120
121	public void testAddAll_ListChangeEvent() throws Exception {
122	assertListChangeEventFired(new Runnable() {
123	public void run() {
124	list.addAll(Arrays.asList(new Object[] { delegate
125	.createElement(list) }));
126	}
127	}, "List.addAll(Collection", list);
128	}
129
130	public void testAddAll_ListDiffEntry() throws Exception {
131	final Object element = delegate.createElement(list);
132
133	assertAddDiffEntry(new Runnable() {
134	public void run() {
135	list.addAll(Arrays.asList(new Object[] { element }));
136	}
137	}, "List.addAll(Collection)", list, element, 0);
138	}
139
140	public void testAddAllAtIndex_ChangeEvent() throws Exception {
141	assertChangeEventFired(new Runnable() {
142	public void run() {
143	list.addAll(0, Arrays.asList(new Object[] { delegate
144	.createElement(list) }));
145	}
146	}, "List.addAll(int, Collection)", list);
147	}
148
149	public void testAddAllAtIndex_ListChangeEvent() throws Exception {
150	assertListChangeEventFired(new Runnable() {
151	public void run() {
152	list.addAll(0, Arrays.asList(new Object[] { delegate
153	.createElement(list) }));
154	}
155	}, "List.addAll(int, Collection)", list);
156	}
157
158	public void testAddAllAtIndex_ChangeEventFiredAfterElementIsAdded()
159	throws Exception {
160	final Object element = delegate.createElement(list);
161
162	assertContainsDuringChangeEvent(new Runnable() {
163	public void run() {
164	list.addAll(0, Arrays.asList(new Object[] { element }));
165	}
166	}, "List.addAll(int, Collection)", list, element);
167	}
168
169	public void testAddAllAtIndex_ListDiffEntry() throws Exception {
170	list.add(delegate.createElement(list));
171	final Object element = delegate.createElement(list);
172
173	assertAddDiffEntry(new Runnable() {
174	public void run() {
175	list.addAll(1, Arrays.asList(new Object[] { element }));
176	}
177	}, "List.addAll(int, Collection)", list, element, 1);
178	}
179
180	public void testSet_ChangeEvent() throws Exception {
181	list.add(delegate.createElement(list));
182
183	assertChangeEventFired(new Runnable() {
184	public void run() {
185	list.set(0, delegate.createElement(list));
186	}
187	}, "List.set(int, Object)", list);
188	}
189
190	public void testSet_ListChangeEvent() throws Exception {
191	list.add(delegate.createElement(list));
192
193	assertListChangeEventFired(new Runnable() {
194	public void run() {
195	list.set(0, delegate.createElement(list));
196	}
197	}, "List.set(int, Object)", list);
198	}
199
200	public void testSet_ChangeEventFiredAfterElementIsSet() throws Exception {
201	Object element1 = delegate.createElement(list);
202	list.add(element1);
203	final Object element2 = delegate.createElement(list);
204
205	assertContainsDuringChangeEvent(new Runnable() {
206	public void run() {
207	list.set(0, element2);
208	}
209	}, "List.set(int, Object)", list, element2);
210	}
211
212	public void testSet_ListDiffEntry() throws Exception {
213	list.add(delegate.createElement(list));
214	Object oldElement = delegate.createElement(list);
215	list.add(oldElement);
216
217	ListChangeEventTracker listener = ListChangeEventTracker.observe(list);
218
219	Object newElement = delegate.createElement(list);
220	list.set(1, newElement);
221
222	ListDiffEntry[] entries = listener.event.diff.getDifferences();
223	assertEquals(
224	"List.set(int, Object) should result in 2 list diff entries.",
225	2, entries.length);
226
227	ListDiffEntry add = null;
228	ListDiffEntry remove = null;
229
230	if (entries[0].isAddition() && !entries[1].isAddition()) {
231	add = entries[0];
232	remove = entries[1];
233	} else if (!entries[0].isAddition() && entries[1].isAddition()) {
234	add = entries[1];
235	remove = entries[0];
236	} else {
237	fail("List.set(int, Object) should result in an add and a remove entry.");
238	}
239
240	assertEquals(
241	"List.set(int, Object) removed element should be the old element.",
242	oldElement, remove.getElement());
243	assertEquals(
244	"List.set(int, Object) removed index should be the index the new element was set at.",
245	1, remove.getPosition());
246
247	assertEquals(
248	"List.set(int, Object) added element should be the set element.",
249	newElement, add.getElement());
250	assertEquals(
251	"List.set(int, Object) add index should be the index the new element was set at.",
252	1, add.getPosition());
253	}
254
255	public void testRemove_ListChangeEvent() throws Exception {
256	final Object element = delegate.createElement(list);
257	list.add(element);
258
259	assertListChangeEventFired(new Runnable() {
260	public void run() {
261	list.remove(element);
262	}
263	}, "List.remove(Object)", list);
264	}
265
266	public void testRemove_ListDiffEntry() throws Exception {
267	list.add(delegate.createElement(list));
268	final Object element = delegate.createElement(list);
269	list.add(element);
270
271	assertRemoveDiffEntry(new Runnable() {
272	public void run() {
273	list.remove(element);
274	}
275	}, "List.remove(Object)", list, element, 1);
276	}
277
278	public void testRemoveAtIndex_ChangeEvent() throws Exception {
279	list.add(delegate.createElement(list));
280
281	assertChangeEventFired(new Runnable() {
282	public void run() {
283	list.remove(0);
284	}
285	}, "List.remove(int)", list);
286	}
287
288	public void testRemoveAtIndex_ListChangeEvent() throws Exception {
289	list.add(delegate.createElement(list));
290
291	assertListChangeEventFired(new Runnable() {
292	public void run() {
293	list.remove(0);
294	}
295	}, "List.remove(int)", list);
296	}
297
298	public void testRemoveAtIndex_ChangeEventFiredAfterElementIsRemoved()
299	throws Exception {
300	final Object element = delegate.createElement(list);
301	list.add(element);
302
303	assertDoesNotContainDuringChangeEvent(new Runnable() {
304	public void run() {
305	list.remove(0);
306	}
307	}, "List.remove(int)", list, element);
308	}
309
310	public void testRemoveAtIndex_ListDiffEntry() throws Exception {
311	list.add(delegate.createElement(list));
312	Object element = delegate.createElement(list);
313	list.add(element);
314
315	assertRemoveDiffEntry(new Runnable() {
316	public void run() {
317	list.remove(1);
318	}
319	}, "List.remove(int)", list, element, 1);
320	}
321
322	public void testRemoveAll_ListChangeEvent() throws Exception {
323	final Object element = delegate.createElement(list);
324
325	assertListChangeEventFired(new Runnable() {
326	public void run() {
327	list.removeAll(Arrays.asList(new Object[] { element }));
328	}
329	}, "List.removeAll(Collection)", list);
330	}
331
332	public void testRemoveAll_ListDiffEntry() throws Exception {
333	final Object element = delegate.createElement(list);
334	list.add(element);
335
336	assertRemoveDiffEntry(new Runnable() {
337	public void run() {
338	list.removeAll(Arrays.asList(new Object[] { element }));
339	}
340	}, "List.removeAll(Collection)", list, element, 0);
341	}
342
343	public void testRetainAll_ListChangeEvent() throws Exception {
344	final Object element1 = delegate.createElement(list);
345	list.add(element1);
346	list.add(delegate.createElement(list));
347
348	assertListChangeEventFired(new Runnable() {
349	public void run() {
350	list.retainAll(Arrays.asList(new Object[] { element1 }));
351	}
352	}, "List.retainAll(Collection", list);
353	}
354
355	public void testRetainAll_ListDiffEntry() throws Exception {
356	final Object element1 = delegate.createElement(list);
357	list.add(element1);
358	Object element2 = delegate.createElement(list);
359	list.add(delegate.createElement(list));
360
361	assertRemoveDiffEntry(new Runnable() {
362	public void run() {
363	list.retainAll(Arrays.asList(new Object[] { element1 }));
364	}
365	}, "List.retainAll(Collection)", list, element2, 1);
366	}
367
368	public void testClear_ListChangeEvent() throws Exception {
369	list.add(delegate.createElement(list));
370
371	assertListChangeEventFired(new Runnable() {
372	public void run() {
373	list.clear();
374	}
375	}, "List.clear()", list);
376	}
377
378	public void testClear_ListDiffEntry() throws Exception {
379	Object element = delegate.createElement(list);
380	list.add(element);
381
382	assertRemoveDiffEntry(new Runnable() {
383	public void run() {
384	list.clear();
385	}
386	}, "List.clear()", list, element, 0);
387	}
388
389	/**
390	* Asserts standard behaviors of firing list change events.
391	* <ul>
392	* <li>Event fires once.</li>
393	* <li>Source of the event is the provided <code>list</code>.
394	* <li>The list change event is fired after the change event.</li>
395	* </ul>
396	*
397	* @param runnable
398	* @param methodName
399	* @param list
400	*/
401	private void assertListChangeEventFired(Runnable runnable,
402	String methodName, IObservableList list) {
403	List queue = new ArrayList();
404	ListChangeEventTracker listListener = new ListChangeEventTracker(queue);
405	ChangeEventTracker changeListener = new ChangeEventTracker(queue);
406
407	list.addListChangeListener(listListener);
408	list.addChangeListener(changeListener);
409
410	runnable.run();
411
412	assertEquals(formatFail(methodName + " should fire one ListChangeEvent."), 1,
413	listListener.count);
414	assertEquals(formatFail(methodName
415	+ "'s change event observable should be the created List."),
416	list, listListener.event.getObservable());
417
418	assertEquals(formatFail("Two notifications should have been received."), 2, queue
419	.size());
420	assertEquals("ChangeEvent of " + methodName
421	+ " should have fired before the ListChangeEvent.",
422	changeListener, queue.get(0));
423	assertEquals("ListChangeEvent of " + methodName
424	+ " should have fired after the ChangeEvent.", listListener,
425	queue.get(1));
426	}
427
428	/**
429	* Asserts the list diff entry for a remove operation.
430	*
431	* @param runnable
432	* @param methodName
433	* @param list
434	* @param element
435	* @param index
436	*/
437	private void assertRemoveDiffEntry(Runnable runnable, String methodName,
438	IObservableList list, Object element, int index) {
439	ListChangeEventTracker listener = new ListChangeEventTracker();
440	list.addListChangeListener(listener);
441
442	runnable.run();
443
444	ListDiffEntry[] entries = listener.event.diff.getDifferences();
445	assertEquals(methodName + " should result in one diff entry.", 1,
446	entries.length);
447
448	ListDiffEntry entry = entries[0];
449	assertFalse(methodName
450	+ " should result in a diff entry that is an removal.", entry
451	.isAddition());
452	assertEquals(methodName
453	+ " remove diff entry should have removed the element.",
454	element, entry.getElement());
455	assertEquals(
456	methodName
457	+ " remove diff entry should have removed the element from the provided index.",
458	index, entry.getPosition());
459	}
460
461	/**
462	* Asserts the list diff entry for an add operation.
463	*
464	* @param runnable
465	* @param methodName
466	* @param list
467	* @param element
468	* @param index
469	*/
470	private void assertAddDiffEntry(Runnable runnable, String methodName,
471	IObservableList list, Object element, int index) {
472	ListChangeEventTracker listener = new ListChangeEventTracker();
473	list.addListChangeListener(listener);
474
475	runnable.run();
476
477	ListDiffEntry[] entries = listener.event.diff.getDifferences();
478	assertEquals(methodName + " should result in one diff entry.", 1,
479	entries.length);
480
481	ListDiffEntry entry = entries[0];
482	assertTrue(methodName
483	+ " should result in a diff entry that is an addition.", entry
484	.isAddition());
485	assertEquals(methodName
486	+ " add diff entry should have added the element.", element,
487	entry.getElement());
488	assertEquals(
489	methodName
490	+ "add diff entry should have added the element at the provided index.",
491	index, entry.getPosition());
492	}
493	}

Added Link Here

(-)META-INF/MANIFEST.MF (+14 lines)
1	Manifest-Version: 1.0
2	Bundle-ManifestVersion: 2
3	Bundle-Name: %pluginName
4	Bundle-SymbolicName: org.eclipse.jface.tests.databinding.conformance
5	Bundle-Version: 1.0.0
6	Require-Bundle: org.junit,
7	org.eclipse.core.databinding,
8	org.eclipse.jface.databinding,
9	org.eclipse.swt,
10	org.eclipse.core.runtime
11	Bundle-Vendor: %providerName
12	Bundle-RequiredExecutionEnvironment: J2SE-1.4
13	Export-Package: org.eclipse.jface.databinding.conformance,
14	org.eclipse.jface.databinding.conformance.util

Added Link Here

(-)src/org/eclipse/jface/databinding/conformance/util/RealmTester.java (+106 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.databinding.conformance.util;
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	}

Added Link Here

(-).settings/org.eclipse.jdt.core.prefs (+66 lines)
1	#Sat Sep 15 18:25:36 MDT 2007
2	eclipse.preferences.version=1
3	org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=disabled
4	org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.2
5	org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
6	org.eclipse.jdt.core.compiler.compliance=1.4
7	org.eclipse.jdt.core.compiler.debug.lineNumber=generate
8	org.eclipse.jdt.core.compiler.debug.localVariable=generate
9	org.eclipse.jdt.core.compiler.debug.sourceFile=generate
10	org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
11	org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
12	org.eclipse.jdt.core.compiler.problem.autoboxing=ignore
13	org.eclipse.jdt.core.compiler.problem.deprecation=warning
14	org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled
15	org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled
16	org.eclipse.jdt.core.compiler.problem.discouragedReference=warning
17	org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore
18	org.eclipse.jdt.core.compiler.problem.enumIdentifier=warning
19	org.eclipse.jdt.core.compiler.problem.fallthroughCase=ignore
20	org.eclipse.jdt.core.compiler.problem.fatalOptionalError=enabled
21	org.eclipse.jdt.core.compiler.problem.fieldHiding=ignore
22	org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning
23	org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning
24	org.eclipse.jdt.core.compiler.problem.forbiddenReference=error
25	org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning
26	org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning
27	org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=ignore
28	org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore
29	org.eclipse.jdt.core.compiler.problem.localVariableHiding=ignore
30	org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning
31	org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=ignore
32	org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=ignore
33	org.eclipse.jdt.core.compiler.problem.missingSerialVersion=warning
34	org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning
35	org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning
36	org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=ignore
37	org.eclipse.jdt.core.compiler.problem.nullReference=ignore
38	org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning
39	org.eclipse.jdt.core.compiler.problem.parameterAssignment=ignore
40	org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=ignore
41	org.eclipse.jdt.core.compiler.problem.potentialNullReference=ignore
42	org.eclipse.jdt.core.compiler.problem.rawTypeReference=warning
43	org.eclipse.jdt.core.compiler.problem.redundantNullCheck=ignore
44	org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled
45	org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning
46	org.eclipse.jdt.core.compiler.problem.suppressWarnings=enabled
47	org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore
48	org.eclipse.jdt.core.compiler.problem.typeParameterHiding=warning
49	org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=warning
50	org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=ignore
51	org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=warning
52	org.eclipse.jdt.core.compiler.problem.unnecessaryElse=ignore
53	org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=ignore
54	org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore
55	org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=ignore
56	org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled
57	org.eclipse.jdt.core.compiler.problem.unusedImport=warning
58	org.eclipse.jdt.core.compiler.problem.unusedLabel=warning
59	org.eclipse.jdt.core.compiler.problem.unusedLocal=warning
60	org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore
61	org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference=enabled
62	org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled
63	org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled
64	org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=warning
65	org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
66	org.eclipse.jdt.core.compiler.source=1.3

Added Link Here

(-)build.properties (+17 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	bin.includes = .,\
12	META-INF/,\
13	plugin.properties,\
14	about.html
15	output.databinding.jar = bin/
16	src.includes = about.html
17	source.. = src/

Added Link Here

(-).project (+28 lines)
1	<?xml version="1.0" encoding="UTF-8"?>
2	<projectDescription>
3	<name>org.eclipse.jface.tests.databinding.conformance</name>
4	<comment></comment>
5	<projects>
6	</projects>
7	<buildSpec>
8	<buildCommand>
9	<name>org.eclipse.jdt.core.javabuilder</name>
10	<arguments>
11	</arguments>
12	</buildCommand>
13	<buildCommand>
14	<name>org.eclipse.pde.ManifestBuilder</name>
15	<arguments>
16	</arguments>
17	</buildCommand>
18	<buildCommand>
19	<name>org.eclipse.pde.SchemaBuilder</name>
20	<arguments>
21	</arguments>
22	</buildCommand>
23	</buildSpec>
24	<natures>
25	<nature>org.eclipse.pde.PluginNature</nature>
26	<nature>org.eclipse.jdt.core.javanature</nature>
27	</natures>
28	</projectDescription>

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	}

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;