Attachment 78508 Details for Bug 182059 – Patch for new project

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

[patch] Patch for new project

test.patch (text/plain), 293.92 KB, created by Brad Reynolds

on 2007-09-15 20:35:25 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Brad Reynolds

Created: 2007-09-15 20:35:25 EDT

Size: 293.92 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.jface.tests.databinding.conformance
>Index: plugin.properties
>===================================================================
>RCS file: plugin.properties
>diff -N plugin.properties
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ plugin.properties	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,12 @@
>+###############################################################################
>+# 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
>Index: src/org/eclipse/jface/databinding/conformance/MutableObservableSetContractTest.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/MutableObservableSetContractTest.java
>diff -N src/org/eclipse/jface/databinding/conformance/MutableObservableSetContractTest.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/MutableObservableSetContractTest.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,266 @@
>+/*******************************************************************************
>+ * 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));
>+	}
>+}
>Index: about.html
>===================================================================
>RCS file: about.html
>diff -N about.html
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ about.html	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,28 @@
>+<!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>
>+ 
>+June 2, 2006	
>+<h3>License</h3>
>+
>+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.
>+
>+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>.
>+
>+</body>
>+</html>
>Index: src/org/eclipse/jface/databinding/conformance/MutableObservableListContractTest.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/MutableObservableListContractTest.java
>diff -N src/org/eclipse/jface/databinding/conformance/MutableObservableListContractTest.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/MutableObservableListContractTest.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,493 @@
>+/*******************************************************************************
>+ * 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.
>+ * 
>+ * 
>+ * 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.
>+ * 
>+ * 
>+ * @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());
>+	}
>+}
>Index: src/org/eclipse/jface/databinding/conformance/swt/SWTMutableObservableValueContractTest.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/swt/SWTMutableObservableValueContractTest.java
>diff -N src/org/eclipse/jface/databinding/conformance/swt/SWTMutableObservableValueContractTest.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/swt/SWTMutableObservableValueContractTest.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,68 @@
>+/*******************************************************************************
>+ * 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.
>+ * 
>+ * 
>+ * 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.
>+ * 
>+ * 
>+ * @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);
>+	}
>+}
>Index: META-INF/MANIFEST.MF
>===================================================================
>RCS file: META-INF/MANIFEST.MF
>diff -N META-INF/MANIFEST.MF
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ META-INF/MANIFEST.MF	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,14 @@
>+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
>Index: src/org/eclipse/jface/databinding/conformance/util/SetChangeEventTracker.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/util/SetChangeEventTracker.java
>diff -N src/org/eclipse/jface/databinding/conformance/util/SetChangeEventTracker.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/util/SetChangeEventTracker.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,47 @@
>+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;
>+	}
>+}
>Index: src/org/eclipse/jface/databinding/conformance/delegate/IObservableContractDelegate.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/delegate/IObservableContractDelegate.java
>diff -N src/org/eclipse/jface/databinding/conformance/delegate/IObservableContractDelegate.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/delegate/IObservableContractDelegate.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,64 @@
>+/*******************************************************************************
>+ * 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.
>+ * 
>+ * 
>+ * 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.
>+ * 
>+ * 
>+ * @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);
>+}
>Index: src/org/eclipse/jface/databinding/conformance/MutableObservableCollectionContractTest.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/MutableObservableCollectionContractTest.java
>diff -N src/org/eclipse/jface/databinding/conformance/MutableObservableCollectionContractTest.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/MutableObservableCollectionContractTest.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,360 @@
>+/*******************************************************************************
>+ * 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.
>+ * 
>+ * 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.
>+ * 
>+ * 
>+ * @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);
>+		}
>+	}
>+}
>Index: src/org/eclipse/jface/databinding/conformance/ObservableListContractTest.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/ObservableListContractTest.java
>diff -N src/org/eclipse/jface/databinding/conformance/ObservableListContractTest.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/ObservableListContractTest.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,109 @@
>+/*******************************************************************************
>+ * 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.
>+ * 
>+ * 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.
>+ * 
>+ * 
>+ * @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);
>+	}
>+}
>Index: src/org/eclipse/jface/databinding/conformance/ObservableStaleContractTest.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/ObservableStaleContractTest.java
>diff -N src/org/eclipse/jface/databinding/conformance/ObservableStaleContractTest.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/ObservableStaleContractTest.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,149 @@
>+/*******************************************************************************
>+ * 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();
>+		}
>+	}
>+
>+}
>Index: src/org/eclipse/jface/databinding/conformance/util/ValueChangeEventTracker.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/util/ValueChangeEventTracker.java
>diff -N src/org/eclipse/jface/databinding/conformance/util/ValueChangeEventTracker.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/util/ValueChangeEventTracker.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,47 @@
>+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;
>+	}
>+}
>Index: src/org/eclipse/jface/databinding/conformance/util/CurrentRealm.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/util/CurrentRealm.java
>diff -N src/org/eclipse/jface/databinding/conformance/util/CurrentRealm.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/util/CurrentRealm.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,42 @@
>+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);
>+	}
>+}
>Index: src/org/eclipse/jface/databinding/conformance/ObservableDelegateTest.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/ObservableDelegateTest.java
>diff -N src/org/eclipse/jface/databinding/conformance/ObservableDelegateTest.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/ObservableDelegateTest.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,107 @@
>+/*******************************************************************************
>+ * 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;
>+	}
>+}
>Index: src/org/eclipse/jface/databinding/conformance/ObservableCollectionContractTest.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/ObservableCollectionContractTest.java
>diff -N src/org/eclipse/jface/databinding/conformance/ObservableCollectionContractTest.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/ObservableCollectionContractTest.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,208 @@
>+/*******************************************************************************
>+ * 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.
>+ * 
>+ * 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.
>+ * 
>+ * 
>+ * @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());
>+	}
>+}
>Index: src/org/eclipse/jface/databinding/conformance/swt/SWTObservableValueContractTest.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/swt/SWTObservableValueContractTest.java
>diff -N src/org/eclipse/jface/databinding/conformance/swt/SWTObservableValueContractTest.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/swt/SWTObservableValueContractTest.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,65 @@
>+/*******************************************************************************
>+ * 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.
>+ * 
>+ * 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.
>+ * 
>+ * 
>+ * @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);
>+	}
>+}
>Index: src/org/eclipse/jface/databinding/conformance/ObservableValueContractTest.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/ObservableValueContractTest.java
>diff -N src/org/eclipse/jface/databinding/conformance/ObservableValueContractTest.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/ObservableValueContractTest.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,170 @@
>+/*******************************************************************************
>+ * 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());
>+	}
>+}
>Index: src/org/eclipse/jface/databinding/conformance/delegate/AbstractObservableValueContractDelegate.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/delegate/AbstractObservableValueContractDelegate.java
>diff -N src/org/eclipse/jface/databinding/conformance/delegate/AbstractObservableValueContractDelegate.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/delegate/AbstractObservableValueContractDelegate.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,55 @@
>+/*******************************************************************************
>+ * 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;
>+	}
>+}
>Index: src/org/eclipse/jface/databinding/conformance/util/RealmTester.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/util/RealmTester.java
>diff -N src/org/eclipse/jface/databinding/conformance/util/RealmTester.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/util/RealmTester.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,106 @@
>+/*******************************************************************************
>+ * 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) {
>+		}
>+	}
>+}
>Index: src/org/eclipse/jface/databinding/conformance/util/ListChangeEventTracker.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/util/ListChangeEventTracker.java
>diff -N src/org/eclipse/jface/databinding/conformance/util/ListChangeEventTracker.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/util/ListChangeEventTracker.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,50 @@
>+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;
>+	}
>+}
>Index: src/org/eclipse/jface/databinding/conformance/delegate/IObservableValueContractDelegate.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/delegate/IObservableValueContractDelegate.java
>diff -N src/org/eclipse/jface/databinding/conformance/delegate/IObservableValueContractDelegate.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/delegate/IObservableValueContractDelegate.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,56 @@
>+/*******************************************************************************
>+ * 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.
>+ * 
>+ * 
>+ * 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.
>+ * 
>+ * 
>+ * @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);
>+}
>Index: src/org/eclipse/jface/databinding/conformance/ObservableContractTest.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/ObservableContractTest.java
>diff -N src/org/eclipse/jface/databinding/conformance/ObservableContractTest.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/ObservableContractTest.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,175 @@
>+/*******************************************************************************
>+ * 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.
>+ * 
>+ * 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.
>+ * 
>+ * 
>+ * @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();
>+		}
>+	}
>+}
>Index: src/org/eclipse/jface/databinding/conformance/delegate/IObservableCollectionContractDelegate.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/delegate/IObservableCollectionContractDelegate.java
>diff -N src/org/eclipse/jface/databinding/conformance/delegate/IObservableCollectionContractDelegate.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/delegate/IObservableCollectionContractDelegate.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,60 @@
>+/*******************************************************************************
>+ * 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.
>+ * 
>+ * 
>+ * 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.
>+ * 
>+ * 
>+ * @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);
>+}
>Index: .settings/org.eclipse.jdt.core.prefs
>===================================================================
>RCS file: .settings/org.eclipse.jdt.core.prefs
>diff -N .settings/org.eclipse.jdt.core.prefs
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ .settings/org.eclipse.jdt.core.prefs	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,66 @@
>+#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
>Index: src/org/eclipse/jface/databinding/conformance/util/ChangeEventTracker.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/util/ChangeEventTracker.java
>diff -N src/org/eclipse/jface/databinding/conformance/util/ChangeEventTracker.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/util/ChangeEventTracker.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,49 @@
>+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;
>+	}
>+}
>Index: src/org/eclipse/jface/databinding/conformance/delegate/AbstractObservableCollectionContractDelegate.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/delegate/AbstractObservableCollectionContractDelegate.java
>diff -N src/org/eclipse/jface/databinding/conformance/delegate/AbstractObservableCollectionContractDelegate.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/delegate/AbstractObservableCollectionContractDelegate.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,45 @@
>+/*******************************************************************************
>+ * 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;
>+	}
>+}
>Index: src/org/eclipse/jface/databinding/conformance/util/SuiteBuilder.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/util/SuiteBuilder.java
>diff -N src/org/eclipse/jface/databinding/conformance/util/SuiteBuilder.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/util/SuiteBuilder.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,181 @@
>+/*******************************************************************************
>+ * 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;
>+		}
>+	}
>+}
>Index: src/org/eclipse/jface/databinding/conformance/MutableObservableValueContractTest.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/MutableObservableValueContractTest.java
>diff -N src/org/eclipse/jface/databinding/conformance/MutableObservableValueContractTest.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/MutableObservableValueContractTest.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,104 @@
>+/*******************************************************************************
>+ * 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.
>+ * 
>+ * 
>+ * 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.
>+ * 
>+ * 
>+ * @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());
>+	}
>+}
>Index: src/org/eclipse/jface/databinding/conformance/delegate/AbstractObservableContractDelegate.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/delegate/AbstractObservableContractDelegate.java
>diff -N src/org/eclipse/jface/databinding/conformance/delegate/AbstractObservableContractDelegate.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/delegate/AbstractObservableContractDelegate.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,39 @@
>+/*******************************************************************************
>+ * 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
>+	}
>+}
>Index: build.properties
>===================================================================
>RCS file: build.properties
>diff -N build.properties
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ build.properties	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,17 @@
>+###############################################################################
>+# 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/
>Index: .classpath
>===================================================================
>RCS file: .classpath
>diff -N .classpath
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ .classpath	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,7 @@
>+<?xml version="1.0" encoding="UTF-8"?>
>+<classpath>
>+	<classpathentry kind="src" path="src"/>
>+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.4"/>
>+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
>+	<classpathentry kind="output" path="bin"/>
>+</classpath>
>Index: src/org/eclipse/jface/databinding/conformance/util/MapChangeEventTracker.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/util/MapChangeEventTracker.java
>diff -N src/org/eclipse/jface/databinding/conformance/util/MapChangeEventTracker.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/util/MapChangeEventTracker.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,47 @@
>+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;
>+	}
>+}
>Index: src/org/eclipse/jface/databinding/conformance/util/DelegatingRealm.java
>===================================================================
>RCS file: src/org/eclipse/jface/databinding/conformance/util/DelegatingRealm.java
>diff -N src/org/eclipse/jface/databinding/conformance/util/DelegatingRealm.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/jface/databinding/conformance/util/DelegatingRealm.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,26 @@
>+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);
>+	}
>+}
>Index: .project
>===================================================================
>RCS file: .project
>diff -N .project
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ .project	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,28 @@
>+<?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>
>#P org.eclipse.jface.tests.databinding
>Index: src/org/eclipse/jface/conformance/databinding/AbstractObservableValueContractDelegate.java
>===================================================================
>RCS file: src/org/eclipse/jface/conformance/databinding/AbstractObservableValueContractDelegate.java
>diff -N src/org/eclipse/jface/conformance/databinding/AbstractObservableValueContractDelegate.java
>--- src/org/eclipse/jface/conformance/databinding/AbstractObservableValueContractDelegate.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,49 +0,0 @@
>-/*******************************************************************************
>- * 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;
>-	}
>-}
>Index: src/org/eclipse/jface/conformance/databinding/ObservableListContractTest.java
>===================================================================
>RCS file: src/org/eclipse/jface/conformance/databinding/ObservableListContractTest.java
>diff -N src/org/eclipse/jface/conformance/databinding/ObservableListContractTest.java
>--- src/org/eclipse/jface/conformance/databinding/ObservableListContractTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,108 +0,0 @@
>-/*******************************************************************************
>- * 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.
>- * 
>- * 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.
>- * 
>- * 
>- * @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);
>-	}
>-}
>Index: src/org/eclipse/jface/conformance/databinding/MutableObservableValueContractTest.java
>===================================================================
>RCS file: src/org/eclipse/jface/conformance/databinding/MutableObservableValueContractTest.java
>diff -N src/org/eclipse/jface/conformance/databinding/MutableObservableValueContractTest.java
>--- src/org/eclipse/jface/conformance/databinding/MutableObservableValueContractTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,104 +0,0 @@
>-/*******************************************************************************
>- * 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.
>- * 
>- * 
>- * 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.
>- * 
>- * 
>- * @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());
>-	}
>-}
>Index: src/org/eclipse/jface/conformance/databinding/MutableObservableListContractTest.java
>===================================================================
>RCS file: src/org/eclipse/jface/conformance/databinding/MutableObservableListContractTest.java
>diff -N src/org/eclipse/jface/conformance/databinding/MutableObservableListContractTest.java
>--- src/org/eclipse/jface/conformance/databinding/MutableObservableListContractTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,492 +0,0 @@
>-/*******************************************************************************
>- * 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.
>- * 
>- * 
>- * 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.
>- * 
>- * 
>- * @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());
>-	}
>-}
>Index: src/org/eclipse/jface/conformance/databinding/IObservableValueContractDelegate.java
>===================================================================
>RCS file: src/org/eclipse/jface/conformance/databinding/IObservableValueContractDelegate.java
>diff -N src/org/eclipse/jface/conformance/databinding/IObservableValueContractDelegate.java
>--- src/org/eclipse/jface/conformance/databinding/IObservableValueContractDelegate.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,56 +0,0 @@
>-/*******************************************************************************
>- * 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.
>- * 
>- * 
>- * 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.
>- * 
>- * 
>- * @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);
>-}
>Index: src/org/eclipse/jface/conformance/databinding/ObservableDelegateTest.java
>===================================================================
>RCS file: src/org/eclipse/jface/conformance/databinding/ObservableDelegateTest.java
>diff -N src/org/eclipse/jface/conformance/databinding/ObservableDelegateTest.java
>--- src/org/eclipse/jface/conformance/databinding/ObservableDelegateTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,106 +0,0 @@
>-/*******************************************************************************
>- * 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;
>-	}
>-}
>Index: src/org/eclipse/jface/conformance/databinding/ObservableValueContractTest.java
>===================================================================
>RCS file: src/org/eclipse/jface/conformance/databinding/ObservableValueContractTest.java
>diff -N src/org/eclipse/jface/conformance/databinding/ObservableValueContractTest.java
>--- src/org/eclipse/jface/conformance/databinding/ObservableValueContractTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,171 +0,0 @@
>-/*******************************************************************************
>- * 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());
>-	}
>-}
>Index: src/org/eclipse/jface/conformance/databinding/MutableObservableSetContractTest.java
>===================================================================
>RCS file: src/org/eclipse/jface/conformance/databinding/MutableObservableSetContractTest.java
>diff -N src/org/eclipse/jface/conformance/databinding/MutableObservableSetContractTest.java
>--- src/org/eclipse/jface/conformance/databinding/MutableObservableSetContractTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,265 +0,0 @@
>-/*******************************************************************************
>- * 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));
>-	}
>-}
>Index: src/org/eclipse/jface/conformance/databinding/SWTMutableObservableValueContractTest.java
>===================================================================
>RCS file: src/org/eclipse/jface/conformance/databinding/SWTMutableObservableValueContractTest.java
>diff -N src/org/eclipse/jface/conformance/databinding/SWTMutableObservableValueContractTest.java
>--- src/org/eclipse/jface/conformance/databinding/SWTMutableObservableValueContractTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,65 +0,0 @@
>-/*******************************************************************************
>- * 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.
>- * 
>- * 
>- * 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.
>- * 
>- * 
>- * @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);
>-	}
>-}
>Index: src/org/eclipse/jface/conformance/databinding/ObservableCollectionContractTest.java
>===================================================================
>RCS file: src/org/eclipse/jface/conformance/databinding/ObservableCollectionContractTest.java
>diff -N src/org/eclipse/jface/conformance/databinding/ObservableCollectionContractTest.java
>--- src/org/eclipse/jface/conformance/databinding/ObservableCollectionContractTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,207 +0,0 @@
>-/*******************************************************************************
>- * 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.
>- * 
>- * 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.
>- * 
>- * 
>- * @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());
>-	}
>-}
>Index: src/org/eclipse/jface/conformance/databinding/AbstractObservableCollectionContractDelegate.java
>===================================================================
>RCS file: src/org/eclipse/jface/conformance/databinding/AbstractObservableCollectionContractDelegate.java
>diff -N src/org/eclipse/jface/conformance/databinding/AbstractObservableCollectionContractDelegate.java
>--- src/org/eclipse/jface/conformance/databinding/AbstractObservableCollectionContractDelegate.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,43 +0,0 @@
>-/*******************************************************************************
>- * 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;
>-	}
>-}
>Index: src/org/eclipse/jface/conformance/databinding/ObservableContractTest.java
>===================================================================
>RCS file: src/org/eclipse/jface/conformance/databinding/ObservableContractTest.java
>diff -N src/org/eclipse/jface/conformance/databinding/ObservableContractTest.java
>--- src/org/eclipse/jface/conformance/databinding/ObservableContractTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,174 +0,0 @@
>-/*******************************************************************************
>- * 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.
>- * 
>- * 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.
>- * 
>- * 
>- * @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();
>-		}
>-	}
>-}
>Index: src/org/eclipse/jface/conformance/databinding/MutableObservableCollectionContractTest.java
>===================================================================
>RCS file: src/org/eclipse/jface/conformance/databinding/MutableObservableCollectionContractTest.java
>diff -N src/org/eclipse/jface/conformance/databinding/MutableObservableCollectionContractTest.java
>--- src/org/eclipse/jface/conformance/databinding/MutableObservableCollectionContractTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,359 +0,0 @@
>-/*******************************************************************************
>- * 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.
>- * 
>- * 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.
>- * 
>- * 
>- * @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);
>-		}
>-	}
>-}
>Index: src/org/eclipse/jface/conformance/databinding/IObservableCollectionContractDelegate.java
>===================================================================
>RCS file: src/org/eclipse/jface/conformance/databinding/IObservableCollectionContractDelegate.java
>diff -N src/org/eclipse/jface/conformance/databinding/IObservableCollectionContractDelegate.java
>--- src/org/eclipse/jface/conformance/databinding/IObservableCollectionContractDelegate.java	9 Sep 2007 03:46:50 -0000	1.2
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,60 +0,0 @@
>-/*******************************************************************************
>- * 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.
>- * 
>- * 
>- * 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.
>- * 
>- * 
>- * @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);
>-}
>Index: src/org/eclipse/jface/conformance/databinding/IObservableContractDelegate.java
>===================================================================
>RCS file: src/org/eclipse/jface/conformance/databinding/IObservableContractDelegate.java
>diff -N src/org/eclipse/jface/conformance/databinding/IObservableContractDelegate.java
>--- src/org/eclipse/jface/conformance/databinding/IObservableContractDelegate.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,64 +0,0 @@
>-/*******************************************************************************
>- * 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.
>- * 
>- * 
>- * 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.
>- * 
>- * 
>- * @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);
>-}
>Index: src/org/eclipse/jface/conformance/databinding/SWTObservableValueContractTest.java
>===================================================================
>RCS file: src/org/eclipse/jface/conformance/databinding/SWTObservableValueContractTest.java
>diff -N src/org/eclipse/jface/conformance/databinding/SWTObservableValueContractTest.java
>--- src/org/eclipse/jface/conformance/databinding/SWTObservableValueContractTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,62 +0,0 @@
>-/*******************************************************************************
>- * 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.
>- * 
>- * 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.
>- * 
>- * 
>- * @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);
>-	}
>-}
>Index: src/org/eclipse/jface/conformance/databinding/AbstractObservableContractDelegate.java
>===================================================================
>RCS file: src/org/eclipse/jface/conformance/databinding/AbstractObservableContractDelegate.java
>diff -N src/org/eclipse/jface/conformance/databinding/AbstractObservableContractDelegate.java
>--- src/org/eclipse/jface/conformance/databinding/AbstractObservableContractDelegate.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,39 +0,0 @@
>-/*******************************************************************************
>- * 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
>-	}
>-}
>Index: src/org/eclipse/jface/conformance/databinding/ObservableStaleContractTest.java
>===================================================================
>RCS file: src/org/eclipse/jface/conformance/databinding/ObservableStaleContractTest.java
>diff -N src/org/eclipse/jface/conformance/databinding/ObservableStaleContractTest.java
>--- src/org/eclipse/jface/conformance/databinding/ObservableStaleContractTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,148 +0,0 @@
>-/*******************************************************************************
>- * 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();
>-		}
>-	}
>-
>-}
>Index: src/org/eclipse/jface/conformance/databinding/SuiteBuilder.java
>===================================================================
>RCS file: src/org/eclipse/jface/conformance/databinding/SuiteBuilder.java
>diff -N src/org/eclipse/jface/conformance/databinding/SuiteBuilder.java
>--- src/org/eclipse/jface/conformance/databinding/SuiteBuilder.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,179 +0,0 @@
>-/*******************************************************************************
>- * 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;
>-		}
>-	}
>-}
>Index: src/org/eclipse/core/tests/databinding/observable/list/AbstractObservableListTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/core/tests/databinding/observable/list/AbstractObservableListTest.java,v
>retrieving revision 1.2
>diff -u -r1.2 AbstractObservableListTest.java
>--- src/org/eclipse/core/tests/databinding/observable/list/AbstractObservableListTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ src/org/eclipse/core/tests/databinding/observable/list/AbstractObservableListTest.java	16 Sep 2007 00:32:58 -0000
>@@ -25,11 +25,11 @@
> import org.eclipse.core.databinding.observable.Realm;
> import org.eclipse.core.databinding.observable.list.AbstractObservableList;
> import org.eclipse.core.databinding.observable.list.ListDiff;
>-import org.eclipse.jface.conformance.databinding.AbstractObservableCollectionContractDelegate;
>-import org.eclipse.jface.conformance.databinding.ObservableListContractTest;
>-import org.eclipse.jface.conformance.databinding.SuiteBuilder;
>-import org.eclipse.jface.tests.databinding.RealmTester;
>-import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;
>+import org.eclipse.jface.databinding.conformance.ObservableListContractTest;
>+import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableCollectionContractDelegate;
>+import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
>+import org.eclipse.jface.databinding.conformance.util.RealmTester;
>+import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
> 
> /**
> * @since 3.2
>Index: src/org/eclipse/core/tests/databinding/observable/list/ObservableListTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/core/tests/databinding/observable/list/ObservableListTest.java,v
>retrieving revision 1.2
>diff -u -r1.2 ObservableListTest.java
>--- src/org/eclipse/core/tests/databinding/observable/list/ObservableListTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ src/org/eclipse/core/tests/databinding/observable/list/ObservableListTest.java	16 Sep 2007 00:32:58 -0000
>@@ -24,11 +24,11 @@
> import org.eclipse.core.databinding.observable.Realm;
> import org.eclipse.core.databinding.observable.list.ListDiff;
> import org.eclipse.core.databinding.observable.list.ObservableList;
>-import org.eclipse.jface.conformance.databinding.AbstractObservableCollectionContractDelegate;
>-import org.eclipse.jface.conformance.databinding.ObservableListContractTest;
>-import org.eclipse.jface.conformance.databinding.SuiteBuilder;
>-import org.eclipse.jface.tests.databinding.RealmTester;
>-import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;
>+import org.eclipse.jface.databinding.conformance.ObservableListContractTest;
>+import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableCollectionContractDelegate;
>+import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
>+import org.eclipse.jface.databinding.conformance.util.RealmTester;
>+import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
> 
> /**
> * @since 3.2
>Index: src/org/eclipse/core/tests/databinding/observable/list/WritableListTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/core/tests/databinding/observable/list/WritableListTest.java,v
>retrieving revision 1.2
>diff -u -r1.2 WritableListTest.java
>--- src/org/eclipse/core/tests/databinding/observable/list/WritableListTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ src/org/eclipse/core/tests/databinding/observable/list/WritableListTest.java	16 Sep 2007 00:32:58 -0000
>@@ -22,13 +22,13 @@
> import org.eclipse.core.databinding.observable.IObservableCollection;
> import org.eclipse.core.databinding.observable.Realm;
> import org.eclipse.core.databinding.observable.list.WritableList;
>-import org.eclipse.jface.conformance.databinding.AbstractObservableCollectionContractDelegate;
>-import org.eclipse.jface.conformance.databinding.MutableObservableListContractTest;
>-import org.eclipse.jface.conformance.databinding.ObservableListContractTest;
>-import org.eclipse.jface.conformance.databinding.SuiteBuilder;
>+import org.eclipse.jface.databinding.conformance.MutableObservableListContractTest;
>+import org.eclipse.jface.databinding.conformance.ObservableListContractTest;
>+import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableCollectionContractDelegate;
>+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.databinding.swt.SWTObservables;
>-import org.eclipse.jface.tests.databinding.RealmTester;
>-import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;
> import org.eclipse.swt.widgets.Display;
> 
> /**
>Index: src/org/eclipse/jface/tests/internal/databinding/internal/swt/ScaleObservableValueMaxTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/internal/databinding/internal/swt/ScaleObservableValueMaxTest.java,v
>retrieving revision 1.2
>diff -u -r1.2 ScaleObservableValueMaxTest.java
>--- src/org/eclipse/jface/tests/internal/databinding/internal/swt/ScaleObservableValueMaxTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ src/org/eclipse/jface/tests/internal/databinding/internal/swt/ScaleObservableValueMaxTest.java	16 Sep 2007 00:32:58 -0000
>@@ -16,11 +16,11 @@
> 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.conformance.databinding.AbstractObservableValueContractDelegate;
>-import org.eclipse.jface.conformance.databinding.ObservableDelegateTest;
>-import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SuiteBuilder;
>+import org.eclipse.jface.databinding.conformance.ObservableDelegateTest;
>+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.swt.SWTObservables;
> import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;
> import org.eclipse.jface.internal.databinding.internal.swt.ScaleObservableValue;
>Index: src/org/eclipse/jface/tests/internal/databinding/internal/swt/SpinnerObservableValueMaxTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/internal/databinding/internal/swt/SpinnerObservableValueMaxTest.java,v
>retrieving revision 1.2
>diff -u -r1.2 SpinnerObservableValueMaxTest.java
>--- src/org/eclipse/jface/tests/internal/databinding/internal/swt/SpinnerObservableValueMaxTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ src/org/eclipse/jface/tests/internal/databinding/internal/swt/SpinnerObservableValueMaxTest.java	16 Sep 2007 00:32:58 -0000
>@@ -16,11 +16,11 @@
> 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.conformance.databinding.AbstractObservableValueContractDelegate;
>-import org.eclipse.jface.conformance.databinding.ObservableDelegateTest;
>-import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SuiteBuilder;
>+import org.eclipse.jface.databinding.conformance.ObservableDelegateTest;
>+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.swt.SWTObservables;
> import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;
> import org.eclipse.jface.internal.databinding.internal.swt.SpinnerObservableValue;
>Index: src/org/eclipse/jface/tests/internal/databinding/internal/swt/ComboObservableValueTextTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/internal/databinding/internal/swt/ComboObservableValueTextTest.java,v
>retrieving revision 1.2
>diff -u -r1.2 ComboObservableValueTextTest.java
>--- src/org/eclipse/jface/tests/internal/databinding/internal/swt/ComboObservableValueTextTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ src/org/eclipse/jface/tests/internal/databinding/internal/swt/ComboObservableValueTextTest.java	16 Sep 2007 00:32:58 -0000
>@@ -17,15 +17,15 @@
> 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.conformance.databinding.AbstractObservableValueContractDelegate;
>-import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SuiteBuilder;
>+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;
>@@ -58,8 +58,8 @@
> 		IObservableValue observable = delegate
> 				.createObservableValue(SWTObservables.getRealm(Display
> 						.getDefault()));
>-		ValueChangeEventTracker listener = new ValueChangeEventTracker()
>-				.register(observable);
>+		ValueChangeEventTracker listener = ValueChangeEventTracker
>+				.observe(observable);
> 
> 		combo.setText((String) delegate.createValue(observable));
> 
>Index: src/org/eclipse/jface/tests/internal/databinding/internal/swt/ComboObservableValueSelectionTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/internal/databinding/internal/swt/ComboObservableValueSelectionTest.java,v
>retrieving revision 1.2
>diff -u -r1.2 ComboObservableValueSelectionTest.java
>--- src/org/eclipse/jface/tests/internal/databinding/internal/swt/ComboObservableValueSelectionTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ src/org/eclipse/jface/tests/internal/databinding/internal/swt/ComboObservableValueSelectionTest.java	16 Sep 2007 00:32:58 -0000
>@@ -17,15 +17,15 @@
> 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.conformance.databinding.AbstractObservableValueContractDelegate;
>-import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SuiteBuilder;
>+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;
>@@ -58,8 +58,8 @@
> 		IObservableValue observable = (IObservableValue) delegate
> 				.createObservable(SWTObservables.getRealm(Display.getDefault()));
> 
>-		ValueChangeEventTracker listener = new ValueChangeEventTracker()
>-				.register(observable);
>+		ValueChangeEventTracker listener = ValueChangeEventTracker
>+				.observe(observable);
> 		combo.select(0);
> 		combo.notifyListeners(SWT.Selection, null);
> 
>Index: src/org/eclipse/jface/tests/internal/databinding/internal/swt/ComboObservableValueTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/internal/databinding/internal/swt/ComboObservableValueTest.java,v
>retrieving revision 1.3
>diff -u -r1.3 ComboObservableValueTest.java
>--- src/org/eclipse/jface/tests/internal/databinding/internal/swt/ComboObservableValueTest.java	9 Sep 2007 03:46:51 -0000	1.3
>+++ src/org/eclipse/jface/tests/internal/databinding/internal/swt/ComboObservableValueTest.java	16 Sep 2007 00:32:58 -0000
>@@ -12,10 +12,10 @@
> 
> package org.eclipse.jface.tests.internal.databinding.internal.swt;
> 
>+import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;
> import org.eclipse.jface.internal.databinding.internal.swt.ComboObservableValue;
> import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;
> 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.Combo;
> 
>Index: src/org/eclipse/jface/tests/internal/databinding/internal/swt/ScaleObservableValueSelectionTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/internal/databinding/internal/swt/ScaleObservableValueSelectionTest.java,v
>retrieving revision 1.2
>diff -u -r1.2 ScaleObservableValueSelectionTest.java
>--- src/org/eclipse/jface/tests/internal/databinding/internal/swt/ScaleObservableValueSelectionTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ src/org/eclipse/jface/tests/internal/databinding/internal/swt/ScaleObservableValueSelectionTest.java	16 Sep 2007 00:32:58 -0000
>@@ -16,11 +16,11 @@
> 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.conformance.databinding.AbstractObservableValueContractDelegate;
>-import org.eclipse.jface.conformance.databinding.ObservableDelegateTest;
>-import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SuiteBuilder;
>+import org.eclipse.jface.databinding.conformance.ObservableDelegateTest;
>+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.swt.SWTObservables;
> import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;
> import org.eclipse.jface.internal.databinding.internal.swt.ScaleObservableValue;
>Index: src/org/eclipse/jface/tests/internal/databinding/internal/swt/LabelObservableValueTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/internal/databinding/internal/swt/LabelObservableValueTest.java,v
>retrieving revision 1.2
>diff -u -r1.2 LabelObservableValueTest.java
>--- src/org/eclipse/jface/tests/internal/databinding/internal/swt/LabelObservableValueTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ src/org/eclipse/jface/tests/internal/databinding/internal/swt/LabelObservableValueTest.java	16 Sep 2007 00:32:58 -0000
>@@ -16,11 +16,11 @@
> 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.conformance.databinding.AbstractObservableValueContractDelegate;
>-import org.eclipse.jface.conformance.databinding.ObservableDelegateTest;
>-import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SuiteBuilder;
>+import org.eclipse.jface.databinding.conformance.ObservableDelegateTest;
>+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.swt.SWTObservables;
> import org.eclipse.jface.internal.databinding.internal.swt.LabelObservableValue;
> import org.eclipse.swt.SWT;
>Index: src/org/eclipse/jface/tests/internal/databinding/internal/swt/CComboObservableValueSelectionTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/internal/databinding/internal/swt/CComboObservableValueSelectionTest.java,v
>retrieving revision 1.2
>diff -u -r1.2 CComboObservableValueSelectionTest.java
>--- src/org/eclipse/jface/tests/internal/databinding/internal/swt/CComboObservableValueSelectionTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ src/org/eclipse/jface/tests/internal/databinding/internal/swt/CComboObservableValueSelectionTest.java	16 Sep 2007 00:32:58 -0000
>@@ -17,15 +17,15 @@
> 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.conformance.databinding.AbstractObservableValueContractDelegate;
>-import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SuiteBuilder;
>+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;
>@@ -57,8 +57,7 @@
> 		IObservableValue observable = (IObservableValue) delegate
> 				.createObservable(SWTObservables.getRealm(Display.getDefault()));
> 
>-		ValueChangeEventTracker listener = new ValueChangeEventTracker()
>-				.register(observable);
>+		ValueChangeEventTracker listener = ValueChangeEventTracker.observe(observable);
> 		combo.select(0);
> 
> 		assertEquals("Observable was not notified.", 1, listener.count);
>Index: src/org/eclipse/jface/tests/internal/databinding/internal/swt/TableSingleSelectionObservableValueTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/internal/databinding/internal/swt/TableSingleSelectionObservableValueTest.java,v
>retrieving revision 1.2
>diff -u -r1.2 TableSingleSelectionObservableValueTest.java
>--- src/org/eclipse/jface/tests/internal/databinding/internal/swt/TableSingleSelectionObservableValueTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ src/org/eclipse/jface/tests/internal/databinding/internal/swt/TableSingleSelectionObservableValueTest.java	16 Sep 2007 00:32:58 -0000
>@@ -16,11 +16,11 @@
> 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.conformance.databinding.AbstractObservableValueContractDelegate;
>-import org.eclipse.jface.conformance.databinding.ObservableDelegateTest;
>-import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SuiteBuilder;
>+import org.eclipse.jface.databinding.conformance.ObservableDelegateTest;
>+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.swt.SWTObservables;
> import org.eclipse.jface.internal.databinding.internal.swt.TableSingleSelectionObservableValue;
> import org.eclipse.jface.util.Assert;
>Index: src/org/eclipse/jface/tests/internal/databinding/internal/swt/TextEditableObservableValueTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/internal/databinding/internal/swt/TextEditableObservableValueTest.java,v
>retrieving revision 1.2
>diff -u -r1.2 TextEditableObservableValueTest.java
>--- src/org/eclipse/jface/tests/internal/databinding/internal/swt/TextEditableObservableValueTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ src/org/eclipse/jface/tests/internal/databinding/internal/swt/TextEditableObservableValueTest.java	16 Sep 2007 00:32:58 -0000
>@@ -16,11 +16,11 @@
> 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.conformance.databinding.AbstractObservableValueContractDelegate;
>-import org.eclipse.jface.conformance.databinding.ObservableDelegateTest;
>-import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SuiteBuilder;
>+import org.eclipse.jface.databinding.conformance.ObservableDelegateTest;
>+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.internal.databinding.internal.swt.TextEditableObservableValue;
> import org.eclipse.swt.SWT;
> import org.eclipse.swt.widgets.Shell;
>Index: src/org/eclipse/jface/tests/internal/databinding/internal/swt/ScaleObservableValueMinTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/internal/databinding/internal/swt/ScaleObservableValueMinTest.java,v
>retrieving revision 1.2
>diff -u -r1.2 ScaleObservableValueMinTest.java
>--- src/org/eclipse/jface/tests/internal/databinding/internal/swt/ScaleObservableValueMinTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ src/org/eclipse/jface/tests/internal/databinding/internal/swt/ScaleObservableValueMinTest.java	16 Sep 2007 00:32:58 -0000
>@@ -16,11 +16,11 @@
> 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.conformance.databinding.AbstractObservableValueContractDelegate;
>-import org.eclipse.jface.conformance.databinding.ObservableDelegateTest;
>-import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SuiteBuilder;
>+import org.eclipse.jface.databinding.conformance.ObservableDelegateTest;
>+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.swt.SWTObservables;
> import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;
> import org.eclipse.jface.internal.databinding.internal.swt.ScaleObservableValue;
>Index: src/org/eclipse/jface/tests/internal/databinding/internal/swt/SpinnerObservableValueTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/internal/databinding/internal/swt/SpinnerObservableValueTest.java,v
>retrieving revision 1.4
>diff -u -r1.4 SpinnerObservableValueTest.java
>--- src/org/eclipse/jface/tests/internal/databinding/internal/swt/SpinnerObservableValueTest.java	9 Sep 2007 03:46:51 -0000	1.4
>+++ src/org/eclipse/jface/tests/internal/databinding/internal/swt/SpinnerObservableValueTest.java	16 Sep 2007 00:32:58 -0000
>@@ -12,10 +12,10 @@
> 
> package org.eclipse.jface.tests.internal.databinding.internal.swt;
> 
>+import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;
> import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;
> import org.eclipse.jface.internal.databinding.internal.swt.SpinnerObservableValue;
> 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.Spinner;
> 
>Index: src/org/eclipse/jface/tests/internal/databinding/internal/swt/ButtonObservableValueTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/internal/databinding/internal/swt/ButtonObservableValueTest.java,v
>retrieving revision 1.3
>diff -u -r1.3 ButtonObservableValueTest.java
>--- src/org/eclipse/jface/tests/internal/databinding/internal/swt/ButtonObservableValueTest.java	9 Sep 2007 03:46:51 -0000	1.3
>+++ src/org/eclipse/jface/tests/internal/databinding/internal/swt/ButtonObservableValueTest.java	16 Sep 2007 00:32:58 -0000
>@@ -17,13 +17,13 @@
> 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.conformance.databinding.AbstractObservableValueContractDelegate;
>-import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SuiteBuilder;
>+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;
>Index: src/org/eclipse/jface/tests/internal/databinding/internal/swt/TextObservableValueTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/internal/databinding/internal/swt/TextObservableValueTest.java,v
>retrieving revision 1.4
>diff -u -r1.4 TextObservableValueTest.java
>--- src/org/eclipse/jface/tests/internal/databinding/internal/swt/TextObservableValueTest.java	9 Sep 2007 03:46:51 -0000	1.4
>+++ src/org/eclipse/jface/tests/internal/databinding/internal/swt/TextObservableValueTest.java	16 Sep 2007 00:32:58 -0000
>@@ -14,9 +14,9 @@
> 
> package org.eclipse.jface.tests.internal.databinding.internal.swt;
> 
>+import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;
> import org.eclipse.jface.internal.databinding.internal.swt.TextObservableValue;
> import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
>-import org.eclipse.jface.tests.databinding.EventTrackers.ValueChangeEventTracker;
> import org.eclipse.swt.SWT;
> import org.eclipse.swt.widgets.Shell;
> import org.eclipse.swt.widgets.Text;
>Index: src/org/eclipse/jface/tests/internal/databinding/internal/swt/CComboObservableValueTextTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/internal/databinding/internal/swt/CComboObservableValueTextTest.java,v
>retrieving revision 1.2
>diff -u -r1.2 CComboObservableValueTextTest.java
>--- src/org/eclipse/jface/tests/internal/databinding/internal/swt/CComboObservableValueTextTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ src/org/eclipse/jface/tests/internal/databinding/internal/swt/CComboObservableValueTextTest.java	16 Sep 2007 00:32:58 -0000
>@@ -17,15 +17,15 @@
> 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.conformance.databinding.AbstractObservableValueContractDelegate;
>-import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SuiteBuilder;
>+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;
>@@ -57,8 +57,8 @@
> 		IObservableValue observable = delegate
> 				.createObservableValue(SWTObservables.getRealm(Display
> 						.getDefault()));
>-		ValueChangeEventTracker listener = new ValueChangeEventTracker()
>-				.register(observable);
>+		ValueChangeEventTracker listener = ValueChangeEventTracker
>+				.observe(observable);
> 
> 		combo.setText((String) delegate.createValue(observable));
> 
>Index: src/org/eclipse/jface/tests/internal/databinding/internal/swt/CLabelObservableValueTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/internal/databinding/internal/swt/CLabelObservableValueTest.java,v
>retrieving revision 1.2
>diff -u -r1.2 CLabelObservableValueTest.java
>--- src/org/eclipse/jface/tests/internal/databinding/internal/swt/CLabelObservableValueTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ src/org/eclipse/jface/tests/internal/databinding/internal/swt/CLabelObservableValueTest.java	16 Sep 2007 00:32:58 -0000
>@@ -17,10 +17,10 @@
> 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.conformance.databinding.AbstractObservableValueContractDelegate;
>-import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SuiteBuilder;
>+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.swt.SWTObservables;
> import org.eclipse.jface.internal.databinding.internal.swt.CLabelObservableValue;
> import org.eclipse.swt.SWT;
>Index: src/org/eclipse/jface/tests/internal/databinding/internal/swt/SpinnerObservableValueMinTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/internal/databinding/internal/swt/SpinnerObservableValueMinTest.java,v
>retrieving revision 1.2
>diff -u -r1.2 SpinnerObservableValueMinTest.java
>--- src/org/eclipse/jface/tests/internal/databinding/internal/swt/SpinnerObservableValueMinTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ src/org/eclipse/jface/tests/internal/databinding/internal/swt/SpinnerObservableValueMinTest.java	16 Sep 2007 00:32:58 -0000
>@@ -16,11 +16,11 @@
> 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.conformance.databinding.AbstractObservableValueContractDelegate;
>-import org.eclipse.jface.conformance.databinding.ObservableDelegateTest;
>-import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SuiteBuilder;
>+import org.eclipse.jface.databinding.conformance.ObservableDelegateTest;
>+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.swt.SWTObservables;
> import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;
> import org.eclipse.jface.internal.databinding.internal.swt.SpinnerObservableValue;
>Index: src/org/eclipse/jface/tests/internal/databinding/internal/swt/CComboSingleSelectionObservableValueTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/internal/databinding/internal/swt/CComboSingleSelectionObservableValueTest.java,v
>retrieving revision 1.3
>diff -u -r1.3 CComboSingleSelectionObservableValueTest.java
>--- src/org/eclipse/jface/tests/internal/databinding/internal/swt/CComboSingleSelectionObservableValueTest.java	9 Sep 2007 03:46:51 -0000	1.3
>+++ src/org/eclipse/jface/tests/internal/databinding/internal/swt/CComboSingleSelectionObservableValueTest.java	16 Sep 2007 00:32:58 -0000
>@@ -17,10 +17,10 @@
> 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.conformance.databinding.AbstractObservableValueContractDelegate;
>-import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SuiteBuilder;
>+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.swt.ISWTObservable;
> import org.eclipse.jface.internal.databinding.internal.swt.CComboSingleSelectionObservableValue;
> import org.eclipse.jface.tests.databinding.AbstractSWTTestCase;
>Index: src/org/eclipse/jface/tests/internal/databinding/internal/swt/CComboObservableValueTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/internal/databinding/internal/swt/CComboObservableValueTest.java,v
>retrieving revision 1.3
>diff -u -r1.3 CComboObservableValueTest.java
>--- src/org/eclipse/jface/tests/internal/databinding/internal/swt/CComboObservableValueTest.java	9 Sep 2007 03:46:51 -0000	1.3
>+++ src/org/eclipse/jface/tests/internal/databinding/internal/swt/CComboObservableValueTest.java	16 Sep 2007 00:32:58 -0000
>@@ -12,10 +12,10 @@
> 
> package org.eclipse.jface.tests.internal.databinding.internal.swt;
> 
>+import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;
> import org.eclipse.jface.internal.databinding.internal.swt.CComboObservableValue;
> import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;
> import org.eclipse.jface.tests.databinding.AbstractSWTTestCase;
>-import org.eclipse.jface.tests.databinding.EventTrackers.ValueChangeEventTracker;
> import org.eclipse.swt.SWT;
> import org.eclipse.swt.custom.CCombo;
> 
>Index: src/org/eclipse/jface/tests/internal/databinding/internal/swt/SpinnerObservableValueSelectionTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/internal/databinding/internal/swt/SpinnerObservableValueSelectionTest.java,v
>retrieving revision 1.2
>diff -u -r1.2 SpinnerObservableValueSelectionTest.java
>--- src/org/eclipse/jface/tests/internal/databinding/internal/swt/SpinnerObservableValueSelectionTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ src/org/eclipse/jface/tests/internal/databinding/internal/swt/SpinnerObservableValueSelectionTest.java	16 Sep 2007 00:32:58 -0000
>@@ -16,11 +16,11 @@
> 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.conformance.databinding.AbstractObservableValueContractDelegate;
>-import org.eclipse.jface.conformance.databinding.ObservableDelegateTest;
>-import org.eclipse.jface.conformance.databinding.SWTMutableObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SWTObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SuiteBuilder;
>+import org.eclipse.jface.databinding.conformance.ObservableDelegateTest;
>+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.swt.SWTObservables;
> import org.eclipse.jface.internal.databinding.internal.swt.SWTProperties;
> import org.eclipse.jface.internal.databinding.internal.swt.SpinnerObservableValue;
>Index: src/org/eclipse/core/tests/databinding/observable/map/WritableMapTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/core/tests/databinding/observable/map/WritableMapTest.java,v
>retrieving revision 1.4
>diff -u -r1.4 WritableMapTest.java
>--- src/org/eclipse/core/tests/databinding/observable/map/WritableMapTest.java	1 May 2007 01:57:22 -0000	1.4
>+++ src/org/eclipse/core/tests/databinding/observable/map/WritableMapTest.java	16 Sep 2007 00:32:58 -0000
>@@ -19,9 +19,9 @@
> import org.eclipse.core.databinding.observable.Realm;
> import org.eclipse.core.databinding.observable.map.MapChangeEvent;
> import org.eclipse.core.databinding.observable.map.WritableMap;
>-import org.eclipse.jface.tests.databinding.RealmTester;
>-import org.eclipse.jface.tests.databinding.EventTrackers.MapChangeEventTracker;
>-import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;
>+import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
>+import org.eclipse.jface.databinding.conformance.util.MapChangeEventTracker;
>+import org.eclipse.jface.databinding.conformance.util.RealmTester;
> 
> /**
> * @since 3.2
>Index: src/org/eclipse/core/tests/databinding/observable/map/ObservableMapTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/core/tests/databinding/observable/map/ObservableMapTest.java,v
>retrieving revision 1.6
>diff -u -r1.6 ObservableMapTest.java
>--- src/org/eclipse/core/tests/databinding/observable/map/ObservableMapTest.java	14 Apr 2007 20:46:40 -0000	1.6
>+++ src/org/eclipse/core/tests/databinding/observable/map/ObservableMapTest.java	16 Sep 2007 00:32:58 -0000
>@@ -20,8 +20,8 @@
> import org.eclipse.core.databinding.observable.map.MapChangeEvent;
> import org.eclipse.core.databinding.observable.map.MapDiff;
> import org.eclipse.core.databinding.observable.map.ObservableMap;
>-import org.eclipse.jface.tests.databinding.RealmTester;
>-import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;
>+import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
>+import org.eclipse.jface.databinding.conformance.util.RealmTester;
> 
> /**
> * @since 3.2
>Index: src/org/eclipse/core/tests/databinding/observable/map/AbstractObservableMapTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/core/tests/databinding/observable/map/AbstractObservableMapTest.java,v
>retrieving revision 1.3
>diff -u -r1.3 AbstractObservableMapTest.java
>--- src/org/eclipse/core/tests/databinding/observable/map/AbstractObservableMapTest.java	14 Apr 2007 20:46:40 -0000	1.3
>+++ src/org/eclipse/core/tests/databinding/observable/map/AbstractObservableMapTest.java	16 Sep 2007 00:32:58 -0000
>@@ -17,8 +17,8 @@
> 
> import org.eclipse.core.databinding.observable.map.AbstractObservableMap;
> import org.eclipse.core.databinding.observable.map.MapDiff;
>-import org.eclipse.jface.tests.databinding.RealmTester;
>-import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;
>+import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
>+import org.eclipse.jface.databinding.conformance.util.RealmTester;
> 
> /**
> * @since 3.2
>Index: src/org/eclipse/jface/tests/databinding/swt/SWTObservablesTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/databinding/swt/SWTObservablesTest.java,v
>retrieving revision 1.7
>diff -u -r1.7 SWTObservablesTest.java
>--- src/org/eclipse/jface/tests/databinding/swt/SWTObservablesTest.java	15 May 2007 19:52:36 -0000	1.7
>+++ src/org/eclipse/jface/tests/databinding/swt/SWTObservablesTest.java	16 Sep 2007 00:32:58 -0000
>@@ -12,6 +12,7 @@
> package org.eclipse.jface.tests.databinding.swt;
> 
> import org.eclipse.core.databinding.observable.list.IObservableList;
>+import org.eclipse.jface.databinding.conformance.util.RealmTester;
> import org.eclipse.jface.databinding.swt.ISWTObservableValue;
> import org.eclipse.jface.databinding.swt.SWTObservables;
> import org.eclipse.jface.internal.databinding.internal.swt.ButtonObservableValue;
>@@ -30,7 +31,6 @@
> import org.eclipse.jface.internal.databinding.internal.swt.TextEditableObservableValue;
> import org.eclipse.jface.internal.databinding.internal.swt.TextObservableValue;
> import org.eclipse.jface.tests.databinding.AbstractSWTTestCase;
>-import org.eclipse.jface.tests.databinding.RealmTester;
> import org.eclipse.swt.SWT;
> import org.eclipse.swt.custom.CCombo;
> import org.eclipse.swt.custom.CLabel;
>Index: src/org/eclipse/core/tests/databinding/observable/set/UnionSetTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/core/tests/databinding/observable/set/UnionSetTest.java,v
>retrieving revision 1.2
>diff -u -r1.2 UnionSetTest.java
>--- src/org/eclipse/core/tests/databinding/observable/set/UnionSetTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ src/org/eclipse/core/tests/databinding/observable/set/UnionSetTest.java	16 Sep 2007 00:32:58 -0000
>@@ -20,9 +20,9 @@
> import org.eclipse.core.databinding.observable.set.IObservableSet;
> import org.eclipse.core.databinding.observable.set.UnionSet;
> import org.eclipse.core.databinding.observable.set.WritableSet;
>-import org.eclipse.jface.conformance.databinding.AbstractObservableCollectionContractDelegate;
>-import org.eclipse.jface.conformance.databinding.ObservableCollectionContractTest;
>-import org.eclipse.jface.conformance.databinding.SuiteBuilder;
>+import org.eclipse.jface.databinding.conformance.ObservableCollectionContractTest;
>+import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableCollectionContractDelegate;
>+import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
> 
> /**
> */
>Index: src/org/eclipse/core/tests/databinding/observable/set/AbstractObservableSetTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/core/tests/databinding/observable/set/AbstractObservableSetTest.java,v
>retrieving revision 1.2
>diff -u -r1.2 AbstractObservableSetTest.java
>--- src/org/eclipse/core/tests/databinding/observable/set/AbstractObservableSetTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ src/org/eclipse/core/tests/databinding/observable/set/AbstractObservableSetTest.java	16 Sep 2007 00:32:58 -0000
>@@ -23,9 +23,9 @@
> import org.eclipse.core.databinding.observable.Realm;
> import org.eclipse.core.databinding.observable.set.AbstractObservableSet;
> import org.eclipse.core.databinding.observable.set.SetDiff;
>-import org.eclipse.jface.conformance.databinding.AbstractObservableCollectionContractDelegate;
>-import org.eclipse.jface.conformance.databinding.ObservableCollectionContractTest;
>-import org.eclipse.jface.conformance.databinding.SuiteBuilder;
>+import org.eclipse.jface.databinding.conformance.ObservableCollectionContractTest;
>+import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableCollectionContractDelegate;
>+import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
> 
> /**
> */
>Index: src/org/eclipse/core/tests/databinding/observable/set/ObservableSetTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/core/tests/databinding/observable/set/ObservableSetTest.java,v
>retrieving revision 1.2
>diff -u -r1.2 ObservableSetTest.java
>--- src/org/eclipse/core/tests/databinding/observable/set/ObservableSetTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ src/org/eclipse/core/tests/databinding/observable/set/ObservableSetTest.java	16 Sep 2007 00:32:58 -0000
>@@ -24,9 +24,9 @@
> import org.eclipse.core.databinding.observable.set.IObservableSet;
> import org.eclipse.core.databinding.observable.set.ObservableSet;
> import org.eclipse.core.databinding.observable.set.SetDiff;
>-import org.eclipse.jface.conformance.databinding.AbstractObservableCollectionContractDelegate;
>-import org.eclipse.jface.conformance.databinding.ObservableCollectionContractTest;
>-import org.eclipse.jface.conformance.databinding.SuiteBuilder;
>+import org.eclipse.jface.databinding.conformance.ObservableCollectionContractTest;
>+import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableCollectionContractDelegate;
>+import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
> 
> /**
> * @since 1.1
>Index: src/org/eclipse/core/tests/databinding/observable/set/WritableSetTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/core/tests/databinding/observable/set/WritableSetTest.java,v
>retrieving revision 1.2
>diff -u -r1.2 WritableSetTest.java
>--- src/org/eclipse/core/tests/databinding/observable/set/WritableSetTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ src/org/eclipse/core/tests/databinding/observable/set/WritableSetTest.java	16 Sep 2007 00:32:58 -0000
>@@ -19,10 +19,10 @@
> import org.eclipse.core.databinding.observable.Realm;
> import org.eclipse.core.databinding.observable.set.IObservableSet;
> import org.eclipse.core.databinding.observable.set.WritableSet;
>-import org.eclipse.jface.conformance.databinding.AbstractObservableCollectionContractDelegate;
>-import org.eclipse.jface.conformance.databinding.MutableObservableSetContractTest;
>-import org.eclipse.jface.conformance.databinding.ObservableCollectionContractTest;
>-import org.eclipse.jface.conformance.databinding.SuiteBuilder;
>+import org.eclipse.jface.databinding.conformance.MutableObservableSetContractTest;
>+import org.eclipse.jface.databinding.conformance.ObservableCollectionContractTest;
>+import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableCollectionContractDelegate;
>+import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
> import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
> 
> /**
>Index: src/org/eclipse/jface/tests/internal/databinding/internal/viewers/SelectionProviderSingleSelectionObservableValueTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/internal/databinding/internal/viewers/SelectionProviderSingleSelectionObservableValueTest.java,v
>retrieving revision 1.9
>diff -u -r1.9 SelectionProviderSingleSelectionObservableValueTest.java
>--- src/org/eclipse/jface/tests/internal/databinding/internal/viewers/SelectionProviderSingleSelectionObservableValueTest.java	9 Sep 2007 03:46:51 -0000	1.9
>+++ src/org/eclipse/jface/tests/internal/databinding/internal/viewers/SelectionProviderSingleSelectionObservableValueTest.java	16 Sep 2007 00:32:59 -0000
>@@ -14,9 +14,9 @@
> 
> import junit.framework.TestCase;
> 
>+import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;
> import org.eclipse.jface.databinding.swt.SWTObservables;
> import org.eclipse.jface.internal.databinding.internal.viewers.SelectionProviderSingleSelectionObservableValue;
>-import org.eclipse.jface.tests.databinding.EventTrackers.ValueChangeEventTracker;
> import org.eclipse.jface.viewers.ISelectionProvider;
> import org.eclipse.jface.viewers.IStructuredContentProvider;
> import org.eclipse.jface.viewers.StructuredSelection;
>Index: src/org/eclipse/jface/tests/internal/databinding/internal/viewers/SelectionProviderMultiSelectionObservableListTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/internal/databinding/internal/viewers/SelectionProviderMultiSelectionObservableListTest.java,v
>retrieving revision 1.1
>diff -u -r1.1 SelectionProviderMultiSelectionObservableListTest.java
>--- src/org/eclipse/jface/tests/internal/databinding/internal/viewers/SelectionProviderMultiSelectionObservableListTest.java	17 Aug 2007 20:30:10 -0000	1.1
>+++ src/org/eclipse/jface/tests/internal/databinding/internal/viewers/SelectionProviderMultiSelectionObservableListTest.java	16 Sep 2007 00:32:59 -0000
>@@ -14,9 +14,9 @@
> import junit.framework.TestCase;
> 
> import org.eclipse.core.databinding.observable.list.ListDiffEntry;
>+import org.eclipse.jface.databinding.conformance.util.ListChangeEventTracker;
> import org.eclipse.jface.databinding.swt.SWTObservables;
> import org.eclipse.jface.internal.databinding.internal.viewers.SelectionProviderMultipleSelectionObservableList;
>-import org.eclipse.jface.tests.databinding.EventTrackers.ListChangeEventTracker;
> import org.eclipse.jface.viewers.ISelectionProvider;
> import org.eclipse.jface.viewers.IStructuredContentProvider;
> import org.eclipse.jface.viewers.IStructuredSelection;
>Index: src/org/eclipse/core/tests/databinding/observable/AbstractObservableTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/core/tests/databinding/observable/AbstractObservableTest.java,v
>retrieving revision 1.2
>diff -u -r1.2 AbstractObservableTest.java
>--- src/org/eclipse/core/tests/databinding/observable/AbstractObservableTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ src/org/eclipse/core/tests/databinding/observable/AbstractObservableTest.java	16 Sep 2007 00:32:58 -0000
>@@ -19,14 +19,14 @@
> 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.conformance.databinding.AbstractObservableContractDelegate;
>-import org.eclipse.jface.conformance.databinding.ObservableContractTest;
>-import org.eclipse.jface.conformance.databinding.ObservableStaleContractTest;
>-import org.eclipse.jface.conformance.databinding.SuiteBuilder;
>+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.
>Index: src/org/eclipse/core/tests/databinding/observable/RealmTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/core/tests/databinding/observable/RealmTest.java,v
>retrieving revision 1.4
>diff -u -r1.4 RealmTest.java
>--- src/org/eclipse/core/tests/databinding/observable/RealmTest.java	14 Apr 2007 20:46:40 -0000	1.4
>+++ src/org/eclipse/core/tests/databinding/observable/RealmTest.java	16 Sep 2007 00:32:58 -0000
>@@ -14,8 +14,8 @@
> import junit.framework.TestCase;
> 
> import org.eclipse.core.databinding.observable.Realm;
>-import org.eclipse.jface.tests.databinding.RealmTester;
>-import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;
>+import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
>+import org.eclipse.jface.databinding.conformance.util.RealmTester;
> 
> /**
> * @since 3.2
>Index: src/org/eclipse/jface/tests/databinding/AbstractDefaultRealmTestCase.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/databinding/AbstractDefaultRealmTestCase.java,v
>retrieving revision 1.3
>diff -u -r1.3 AbstractDefaultRealmTestCase.java
>--- src/org/eclipse/jface/tests/databinding/AbstractDefaultRealmTestCase.java	14 Apr 2007 20:46:39 -0000	1.3
>+++ src/org/eclipse/jface/tests/databinding/AbstractDefaultRealmTestCase.java	16 Sep 2007 00:32:58 -0000
>@@ -14,6 +14,7 @@
> import junit.framework.TestCase;
> 
> import org.eclipse.core.databinding.observable.Realm;
>+import org.eclipse.jface.databinding.conformance.util.RealmTester;
> import org.eclipse.jface.databinding.swt.SWTObservables;
> import org.eclipse.swt.widgets.Display;
> 
>Index: src/org/eclipse/jface/tests/databinding/RealmTester.java
>===================================================================
>RCS file: src/org/eclipse/jface/tests/databinding/RealmTester.java
>diff -N src/org/eclipse/jface/tests/databinding/RealmTester.java
>--- src/org/eclipse/jface/tests/databinding/RealmTester.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,168 +0,0 @@
>-/*******************************************************************************
>- * 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);
>-		}
>-	}
>-}
>Index: src/org/eclipse/jface/tests/databinding/EventTrackers.java
>===================================================================
>RCS file: src/org/eclipse/jface/tests/databinding/EventTrackers.java
>diff -N src/org/eclipse/jface/tests/databinding/EventTrackers.java
>--- src/org/eclipse/jface/tests/databinding/EventTrackers.java	9 Sep 2007 03:46:51 -0000	1.4
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,175 +0,0 @@
>-/*******************************************************************************
>- * 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);
>-			}
>-		}
>-	}
>-}
>Index: src/org/eclipse/core/tests/internal/databinding/internal/beans/JavaBeanObservableValueTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/core/tests/internal/databinding/internal/beans/JavaBeanObservableValueTest.java,v
>retrieving revision 1.5
>diff -u -r1.5 JavaBeanObservableValueTest.java
>--- src/org/eclipse/core/tests/internal/databinding/internal/beans/JavaBeanObservableValueTest.java	9 Sep 2007 03:46:51 -0000	1.5
>+++ src/org/eclipse/core/tests/internal/databinding/internal/beans/JavaBeanObservableValueTest.java	16 Sep 2007 00:32:58 -0000
>@@ -26,9 +26,9 @@
> import org.eclipse.core.databinding.observable.value.ComputedValue;
> import org.eclipse.core.databinding.observable.value.IObservableValue;
> import org.eclipse.core.internal.databinding.internal.beans.JavaBeanObservableValue;
>-import org.eclipse.jface.conformance.databinding.AbstractObservableValueContractDelegate;
>-import org.eclipse.jface.conformance.databinding.ObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SuiteBuilder;
>+import org.eclipse.jface.databinding.conformance.ObservableValueContractTest;
>+import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
>+import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
> import org.eclipse.jface.examples.databinding.model.SimplePerson;
> import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
> 
>Index: src/org/eclipse/core/tests/internal/databinding/internal/beans/JavaBeanObservableArrayBasedListTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/core/tests/internal/databinding/internal/beans/JavaBeanObservableArrayBasedListTest.java,v
>retrieving revision 1.1
>diff -u -r1.1 JavaBeanObservableArrayBasedListTest.java
>--- src/org/eclipse/core/tests/internal/databinding/internal/beans/JavaBeanObservableArrayBasedListTest.java	16 May 2007 03:08:42 -0000	1.1
>+++ src/org/eclipse/core/tests/internal/databinding/internal/beans/JavaBeanObservableArrayBasedListTest.java	16 Sep 2007 00:32:58 -0000
>@@ -22,9 +22,9 @@
> import org.eclipse.core.databinding.observable.list.ListChangeEvent;
> import org.eclipse.core.databinding.observable.list.ListDiffEntry;
> import org.eclipse.core.internal.databinding.internal.beans.JavaBeanObservableList;
>+import org.eclipse.jface.databinding.conformance.util.ListChangeEventTracker;
> import org.eclipse.jface.databinding.swt.SWTObservables;
> import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
>-import org.eclipse.jface.tests.databinding.EventTrackers.ListChangeEventTracker;
> import org.eclipse.swt.widgets.Display;
> 
> /**
>Index: src/org/eclipse/core/tests/internal/databinding/internal/beans/JavaBeanObservableListTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/core/tests/internal/databinding/internal/beans/JavaBeanObservableListTest.java,v
>retrieving revision 1.2
>diff -u -r1.2 JavaBeanObservableListTest.java
>--- src/org/eclipse/core/tests/internal/databinding/internal/beans/JavaBeanObservableListTest.java	16 May 2007 03:08:42 -0000	1.2
>+++ src/org/eclipse/core/tests/internal/databinding/internal/beans/JavaBeanObservableListTest.java	16 Sep 2007 00:32:58 -0000
>@@ -22,9 +22,9 @@
> import org.eclipse.core.databinding.observable.list.ListChangeEvent;
> import org.eclipse.core.databinding.observable.list.ListDiffEntry;
> import org.eclipse.core.internal.databinding.internal.beans.JavaBeanObservableList;
>+import org.eclipse.jface.databinding.conformance.util.ListChangeEventTracker;
> import org.eclipse.jface.databinding.swt.SWTObservables;
> import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
>-import org.eclipse.jface.tests.databinding.EventTrackers.ListChangeEventTracker;
> import org.eclipse.swt.widgets.Display;
> 
> /**
>Index: src/org/eclipse/core/tests/databinding/DatabindingContextTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/core/tests/databinding/DatabindingContextTest.java,v
>retrieving revision 1.1
>diff -u -r1.1 DatabindingContextTest.java
>--- src/org/eclipse/core/tests/databinding/DatabindingContextTest.java	14 Apr 2007 20:46:41 -0000	1.1
>+++ src/org/eclipse/core/tests/databinding/DatabindingContextTest.java	16 Sep 2007 00:32:58 -0000
>@@ -29,9 +29,9 @@
> import org.eclipse.core.databinding.validation.IValidator;
> import org.eclipse.core.databinding.validation.ValidationStatus;
> import org.eclipse.core.runtime.IStatus;
>+import org.eclipse.jface.databinding.conformance.util.ChangeEventTracker;
>+import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;
> import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
>-import org.eclipse.jface.tests.databinding.EventTrackers.ChangeEventTracker;
>-import org.eclipse.jface.tests.databinding.EventTrackers.ValueChangeEventTracker;
> 
> public class DatabindingContextTest extends AbstractDefaultRealmTestCase {
> 	private DataBindingContext dbc;
>Index: src/org/eclipse/core/tests/databinding/observable/value/AbstractObservableValueTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/core/tests/databinding/observable/value/AbstractObservableValueTest.java,v
>retrieving revision 1.1
>diff -u -r1.1 AbstractObservableValueTest.java
>--- src/org/eclipse/core/tests/databinding/observable/value/AbstractObservableValueTest.java	14 Apr 2007 20:46:39 -0000	1.1
>+++ src/org/eclipse/core/tests/databinding/observable/value/AbstractObservableValueTest.java	16 Sep 2007 00:32:58 -0000
>@@ -16,8 +16,8 @@
> import org.eclipse.core.databinding.observable.Realm;
> import org.eclipse.core.databinding.observable.value.AbstractObservableValue;
> import org.eclipse.core.databinding.observable.value.ValueDiff;
>-import org.eclipse.jface.tests.databinding.RealmTester;
>-import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;
>+import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
>+import org.eclipse.jface.databinding.conformance.util.RealmTester;
> 
> /**
> * @since 3.2
>Index: src/org/eclipse/core/tests/databinding/observable/value/WritableValueTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/core/tests/databinding/observable/value/WritableValueTest.java,v
>retrieving revision 1.2
>diff -u -r1.2 WritableValueTest.java
>--- src/org/eclipse/core/tests/databinding/observable/value/WritableValueTest.java	9 Sep 2007 03:46:51 -0000	1.2
>+++ src/org/eclipse/core/tests/databinding/observable/value/WritableValueTest.java	16 Sep 2007 00:32:58 -0000
>@@ -18,10 +18,10 @@
> import org.eclipse.core.databinding.observable.Realm;
> import org.eclipse.core.databinding.observable.value.IObservableValue;
> import org.eclipse.core.databinding.observable.value.WritableValue;
>-import org.eclipse.jface.conformance.databinding.AbstractObservableValueContractDelegate;
>-import org.eclipse.jface.conformance.databinding.MutableObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.ObservableValueContractTest;
>-import org.eclipse.jface.conformance.databinding.SuiteBuilder;
>+import org.eclipse.jface.databinding.conformance.MutableObservableValueContractTest;
>+import org.eclipse.jface.databinding.conformance.ObservableValueContractTest;
>+import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
>+import org.eclipse.jface.databinding.conformance.util.SuiteBuilder;
> import org.eclipse.jface.databinding.swt.SWTObservables;
> import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
> import org.eclipse.swt.widgets.Display;
>Index: src/org/eclipse/core/tests/databinding/observable/value/AbstractVetoableValueTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/core/tests/databinding/observable/value/AbstractVetoableValueTest.java,v
>retrieving revision 1.1
>diff -u -r1.1 AbstractVetoableValueTest.java
>--- src/org/eclipse/core/tests/databinding/observable/value/AbstractVetoableValueTest.java	14 Apr 2007 20:46:39 -0000	1.1
>+++ src/org/eclipse/core/tests/databinding/observable/value/AbstractVetoableValueTest.java	16 Sep 2007 00:32:58 -0000
>@@ -16,8 +16,8 @@
> import org.eclipse.core.databinding.observable.Realm;
> import org.eclipse.core.databinding.observable.value.AbstractVetoableValue;
> import org.eclipse.core.databinding.observable.value.ValueDiff;
>-import org.eclipse.jface.tests.databinding.RealmTester;
>-import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;
>+import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
>+import org.eclipse.jface.databinding.conformance.util.RealmTester;
> 
> /**
> * @since 3.2
>Index: META-INF/MANIFEST.MF
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/META-INF/MANIFEST.MF,v
>retrieving revision 1.14
>diff -u -r1.14 MANIFEST.MF
>--- META-INF/MANIFEST.MF	16 Mar 2007 21:19:34 -0000	1.14
>+++ META-INF/MANIFEST.MF	16 Sep 2007 00:32:58 -0000
>@@ -14,6 +14,7 @@
> org.eclipse.core.runtime,
> org.eclipse.jface.examples.databinding,
> org.eclipse.core.databinding.beans,
>- org.eclipse.jface.databinding
>+ org.eclipse.jface.databinding,
>+ org.eclipse.jface.tests.databinding.conformance
> Import-Package: com.ibm.icu.text
> 
>Index: src/org/eclipse/jface/tests/databinding/scenarios/ScenariosTestCase.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/jface/tests/databinding/scenarios/ScenariosTestCase.java,v
>retrieving revision 1.15
>diff -u -r1.15 ScenariosTestCase.java
>--- src/org/eclipse/jface/tests/databinding/scenarios/ScenariosTestCase.java	14 Apr 2007 20:46:40 -0000	1.15
>+++ src/org/eclipse/jface/tests/databinding/scenarios/ScenariosTestCase.java	16 Sep 2007 00:32:58 -0000
>@@ -17,9 +17,9 @@
> 
> import org.eclipse.core.databinding.DataBindingContext;
> import org.eclipse.core.databinding.observable.Realm;
>+import org.eclipse.jface.databinding.conformance.util.RealmTester;
> import org.eclipse.jface.databinding.swt.SWTObservables;
> import org.eclipse.jface.examples.databinding.model.SampleData;
>-import org.eclipse.jface.tests.databinding.RealmTester;
> import org.eclipse.swt.SWT;
> import org.eclipse.swt.layout.FillLayout;
> import org.eclipse.swt.widgets.Button;

Actions: View | Diff

Attachments on bug 182059: 73801 | 78508 | 79178