Attachment #73801 for bug #182059

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

Lines 12-22 Link Here

(-)src/org/eclipse/core/tests/databinding/observable/value/WritableValueTest.java (-38 / +44 lines)
12		12
13	package org.eclipse.core.tests.databinding.observable.value;	13	package org.eclipse.core.tests.databinding.observable.value;
14		14
		15	import junit.framework.Test;
		16	import junit.framework.TestSuite;
		17
		18	import org.eclipse.core.databinding.observable.IObservable;
15	import org.eclipse.core.databinding.observable.Realm;	19	import org.eclipse.core.databinding.observable.Realm;
		20	import org.eclipse.core.databinding.observable.value.IObservableValue;
16	import org.eclipse.core.databinding.observable.value.WritableValue;	21	import org.eclipse.core.databinding.observable.value.WritableValue;
		22	import org.eclipse.jface.conformance.databinding.AbstractObservableValueContractDelegate;
		23	import org.eclipse.jface.conformance.databinding.ObservableValueContractTests;
		24	import org.eclipse.jface.conformance.databinding.SuiteBuilder;
17	import org.eclipse.jface.databinding.swt.SWTObservables;	25	import org.eclipse.jface.databinding.swt.SWTObservables;
18	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;	26	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
19	import org.eclipse.jface.tests.databinding.EventTrackers.ValueChangeEventTracker;
20	import org.eclipse.swt.widgets.Display;	27	import org.eclipse.swt.widgets.Display;
21		28
22	/**	29	/**
Lines 24-65 Link Here
24	*/	31	*/
25	public class WritableValueTest extends AbstractDefaultRealmTestCase {	32	public class WritableValueTest extends AbstractDefaultRealmTestCase {
26	/**	33	/**
27	* Asserts that ValueChange events are only fired when the value changes.
28	*
29	* @throws Exception
30	*/
31	public void testValueChangeOnlyFiresOnChange() throws Exception {
32	WritableValue writableValue = new WritableValue();
33	ValueChangeEventTracker counter = new ValueChangeEventTracker();
34	writableValue.addValueChangeListener(counter);
35
36	assertEquals(0, counter.count);
37	// set same
38	writableValue.setValue(null);
39	assertEquals(0, counter.count);
40
41	// set different
42	writableValue.setValue("value");
43	assertEquals(1, counter.count);
44
45	// set same
46	writableValue.setValue("value");
47	assertEquals(1, counter.count);
48
49	// set different
50	writableValue.setValue(null);
51	assertEquals(2, counter.count);
52	}
53
54	public void testDoSetValue() throws Exception {
55	WritableValue writableValue = new WritableValue(SWTObservables
56	.getRealm(Display.getDefault()));
57	Object value = new Object();
58	writableValue.setValue(value);
59	assertEquals(value, writableValue.getValue());
60	}
61
62	/**
63	* All constructors delegate to the 3 arg constructor.	34	* All constructors delegate to the 3 arg constructor.
64	*	35	*
65	* @throws Exception	36	* @throws Exception
Lines 70-76 Link Here
70	assertNull(value.getValue());	41	assertNull(value.getValue());
71	assertNull(value.getValueType());	42	assertNull(value.getValueType());
72	}	43	}
73		44
74	public void testWithValueType() throws Exception {	45	public void testWithValueType() throws Exception {
75	Object elementType = String.class;	46	Object elementType = String.class;
76	WritableValue value = WritableValue.withValueType(elementType);	47	WritableValue value = WritableValue.withValueType(elementType);
Lines 78-81 Link Here
78	assertEquals(Realm.getDefault(), value.getRealm());	49	assertEquals(Realm.getDefault(), value.getRealm());
79	assertEquals(elementType, value.getValueType());	50	assertEquals(elementType, value.getValueType());
80	}	51	}
		52
		53	public static Test suite() {
		54	TestSuite suite = new TestSuite();
		55	Object[] params = new Object[] { new Delegate() };
		56
		57	SuiteBuilder
		58	.forSuite(suite)
		59	.addTests(WritableValueTest.class)
		60	.addParameterizedTests(ObservableValueContractTests.class, params);
		61
		62	return suite;
		63	}
		64
		65	/* package */ static class Delegate extends AbstractObservableValueContractDelegate {
		66	private WritableValue current;
		67
		68	public IObservableValue createObservableValue() {
		69	Realm.runWithDefault(SWTObservables.getRealm(Display.getDefault()), new Runnable() {
		70	public void run() {
		71	current = new WritableValue("", String.class);
		72	}
		73	});
		74
		75	return current;
		76	}
		77
		78	public void change(IObservable observable) {
		79	WritableValue writableValue = (WritableValue) observable;
		80	writableValue.setValue(writableValue.getValue() + "a");
		81	}
		82
		83	public Object getValueType(IObservableValue observable) {
		84	return String.class;
		85	}
		86	}
81	}	87	}

Lines 12-17 Link Here

(-)src/org/eclipse/core/tests/databinding/observable/AbstractObservableTest.java (-1 / +62 lines)
12		12
13	package org.eclipse.core.tests.databinding.observable;	13	package org.eclipse.core.tests.databinding.observable;
14		14
		15	import junit.framework.Test;
		16	import junit.framework.TestSuite;
		17
15	import org.eclipse.core.databinding.observable.AbstractObservable;	18	import org.eclipse.core.databinding.observable.AbstractObservable;
16	import org.eclipse.core.databinding.observable.ChangeEvent;	19	import org.eclipse.core.databinding.observable.ChangeEvent;
17	import org.eclipse.core.databinding.observable.IChangeListener;	20	import org.eclipse.core.databinding.observable.IChangeListener;
Lines 19-27 Link Here
19	import org.eclipse.core.databinding.observable.IStaleListener;	22	import org.eclipse.core.databinding.observable.IStaleListener;
20	import org.eclipse.core.databinding.observable.Realm;	23	import org.eclipse.core.databinding.observable.Realm;
21	import org.eclipse.core.databinding.observable.StaleEvent;	24	import org.eclipse.core.databinding.observable.StaleEvent;
		25	import org.eclipse.jface.conformance.databinding.AbstractObservableContractDelegate;
		26	import org.eclipse.jface.conformance.databinding.ObservableContractTests;
		27	import org.eclipse.jface.conformance.databinding.ObservableStaleContractTests;
		28	import org.eclipse.jface.conformance.databinding.SuiteBuilder;
		29	import org.eclipse.jface.databinding.swt.SWTObservables;
22	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;	30	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
23	import org.eclipse.jface.tests.databinding.RealmTester;	31	import org.eclipse.jface.tests.databinding.RealmTester;
24	import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;	32	import org.eclipse.jface.tests.databinding.RealmTester.CurrentRealm;
		33	import org.eclipse.swt.widgets.Display;
25		34
26	/**	35	/**
27	* Tests for AbstractObservable.	36	* Tests for AbstractObservable.
Lines 187-192 Link Here
187		196
188	private class ChangeListener implements IChangeListener {	197	private class ChangeListener implements IChangeListener {
189	int count;	198	int count;
		199
190	IObservable source;	200	IObservable source;
191		201
192	public void handleChange(ChangeEvent event) {	202	public void handleChange(ChangeEvent event) {
Lines 197-202 Link Here
197		207
198	private class StaleListener implements IStaleListener {	208	private class StaleListener implements IStaleListener {
199	int count;	209	int count;
		210
200	IObservable source;	211	IObservable source;
201		212
202	public void handleStale(StaleEvent event) {	213	public void handleStale(StaleEvent event) {
Lines 205-211 Link Here
205	}	216	}
206	}	217	}
207		218
		219	public static Test suite() {
		220	TestSuite suite = new TestSuite();
		221	Object[] params = new Object[] { new Delegate() };
		222
		223	SuiteBuilder
		224	.forSuite(suite)
		225	.addTests(AbstractObservableTest.class)
		226	.addParameterizedTests(ObservableContractTests.class, params)
		227	.addParameterizedTests(ObservableStaleContractTests.class,
		228	params);
		229
		230	return suite;
		231	}
		232
		233	/* package */static class Delegate extends
		234	AbstractObservableContractDelegate {
		235	private IObservable currentObservable;
		236
		237	public void change(IObservable observable) {
		238	((ObservableStub) observable).fireChange();
		239	}
		240
		241	public void setStale(IObservable observable, boolean stale) {
		242	((ObservableStub) observable).setStale(stale);
		243	}
		244
		245	public IObservable createObservable() {
		246	Realm.runWithDefault(SWTObservables.getRealm(Display.getDefault()),
		247	new Runnable() {
		248	public void run() {
		249	currentObservable = new ObservableStub();
		250	}
		251	});
		252
		253	return currentObservable;
		254	}
		255	}
		256
208	private static class ObservableStub extends AbstractObservable {	257	private static class ObservableStub extends AbstractObservable {
		258	private boolean stale;
		259
209	public ObservableStub() {	260	public ObservableStub() {
210	this(Realm.getDefault());	261	this(Realm.getDefault());
211	}	262	}
Lines 218-223 Link Here
218	}	269	}
219		270
220	private boolean firstListenerAdded;	271	private boolean firstListenerAdded;
		272
221	private boolean lastListenerRemoved;	273	private boolean lastListenerRemoved;
222		274
223	protected Object doGetValue() {	275	protected Object doGetValue() {
Lines 237-243 Link Here
237	}	289	}
238		290
239	public boolean isStale() {	291	public boolean isStale() {
240	return false;	292	return stale;
		293	}
		294
		295	public void setStale(boolean stale) {
		296	boolean old = this.stale;
		297	this.stale = stale;
		298
		299	if (stale && !old) {
		300	fireStale();
		301	}
241	}	302	}
242		303
243	protected boolean hasListeners() {	304	protected boolean hasListeners() {





package org.eclipse.jface.tests.internal.databinding.internal.swt;

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

import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.jface.conformance.databinding.AbstractObservableValueContractDelegate;
import org.eclipse.jface.conformance.databinding.ObservableValueContractTests;
import org.eclipse.jface.conformance.databinding.SuiteBuilder;
import org.eclipse.jface.internal.databinding.internal.swt.ButtonObservableValue;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Button;


/**
 * @since 3.2
 *
 */
public class ButtonObservableValueTest extends TestCase {    
    public static Test suite() {
		TestSuite suite = new TestSuite();
		Object[] params = new Object[] { new Delegate() };

		SuiteBuilder
				.forSuite(suite)
				.addParameterizedTests(ObservableValueContractTests.class, params);

		return suite;
	}
    
    /* package */ static class Delegate extends AbstractObservableValueContractDelegate {
    	Shell shell;
    	Button button;
    	
    	public void setUp() {
    		super.setUp();
    		
    		shell = new Shell();
    		button = new Button(shell, SWT.CHECK);
    	}
    	
    	public void tearDown() {
    		super.tearDown();
    		
    		shell.dispose();
    	}
    	
    	public IObservableValue createObservableValue() {
    		return new ButtonObservableValue(button);
    	}
    	
    	public Object getValueType(IObservableValue observable) {
    		return Boolean.TYPE;
    	}
    	
    	public void change(IObservable observable) {
    		button.setSelection(!button.getSelection());
    		button.notifyListeners(SWT.Selection, null);
    	}
    }
}




		addTestSuite(StringToNumberConverterTest.class);

		// org.eclipse.core.tests.databinding.observable
		addTest(AbstractObservableTest.suite());
		addTestSuite(Diffs_ListDiffTests.class);
		addTestSuite(DiffsTest.class);
		addTestSuite(ObservablesTest.class);

		addTestSuite(AbstractObservableValueTest.class);
		addTestSuite(AbstractVetoableValueTest.class);
		addTestSuite(ComputedValueTest.class);
		addTest(WritableValueTest.suite());
//		addTestSuite(WritableValueTest.class);
		
		//org.eclipse.core.tests.databinding.validation
		addTestSuite(ValidationStatusTest.class);

		addTestSuite(EditMaskParserTest.class);

		//org.eclipse.jface.tests.internal.databinding.internal.swt
		addTest(ButtonObservableValueTest.suite());
//		addTestSuite(ButtonObservableValueTest.class);
		addTestSuite(CComboObservableValueTest.class);
		addTestSuite(CLabelObservableValueTest.class);
		addTestSuite(ComboObservableValueTest.class);




/*******************************************************************************
 * 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 junit.framework.Test;
import junit.framework.TestSuite;

/**
 * Builds a test suite.
 * 
 * @since 1.1
 */
// TODO remove the forSuite(...) method and add a toSuite() method that returns
// a new TestSuite.
public class SuiteBuilder {
	private TestSuite suite;

	private SuiteBuilder(TestSuite suite) {
		// prohibit public construction
		this.suite = suite;
	}

	/**
	 * Adds all test methods from the provided <code>testCase</code> to the
	 * suite.
	 * 
	 * @param testCase
	 * @return builder
	 */
	public SuiteBuilder addTests(Class testCase) {
		suite.addTestSuite(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) {
		Method[] methods = testCase.getMethods();

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

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

		return this;
	}

	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[i])) {
				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;
	}

	public static SuiteBuilder forSuite(TestSuite suite) {
		return new SuiteBuilder(suite);
	}

	/* package */static class UniqueTest {
		/* package */UniqueTest(Class clazz, String testName,
				Object[] parameters) {

		}
	}
}




/*******************************************************************************
 * 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 junit.framework.TestCase;

import org.eclipse.core.databinding.observable.IObservable;
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.ObservableContractTests.DummyRealm;

/**
 * @since 3.3
 */
public class ObservableStaleContractTests extends TestCase {
	private IObservableContractDelegate delegate;
	private Realm previousRealm;
	
	public ObservableStaleContractTests(String testName, IObservableContractDelegate delegate) {
		super(testName);
		this.delegate = delegate;
	}
	
	protected void setUp() throws Exception {
		super.setUp();

		previousRealm = Realm.getDefault();
		delegate.setUp();
	}

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

		delegate.tearDown();
		DummyRealm.setDefaultRealm(previousRealm);
	}
	
	public void testIsStaleReturnsTrueWhenStale() throws Exception {
		IObservable observable = delegate.createObservable();
		delegate.setStale(observable, true);
		assertTrue("When stale isStale() should return true.", observable.isStale());
	}
	
	public void testIsStaleReturnsFalseWhenNotStale() throws Exception {
		IObservable observable = delegate.createObservable();
		delegate.setStale(observable, false);
		assertFalse("When not stale isStale() should return false.", observable.isStale());
	}

	public void testBecomingStaleFiresStaleEvent() throws Exception {
		IObservable observable = delegate.createObservable();
		StaleListener listener = new StaleListener();

		// precondition
		ensureStale(observable, false);

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

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

	public void testStaleEventObservable() throws Exception {
		IObservable observable = delegate.createObservable();
		StaleListener listener = new StaleListener();

		// precondition
		ensureStale(observable, false);

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

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

	public void testRemoveStaleListenerRemovesListener() throws Exception {
		StaleListener listener = new StaleListener();
		IObservable observable = delegate.createObservable();

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

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

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

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

	public void testStaleListenersAreNotNotifiedWhenObservableIsNoLongerStale()
			throws Exception {
		IObservable observable = delegate.createObservable();
		ensureStale(observable, true);

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

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

	public void testObservableRealmIsCurrentOnStale() throws Exception {
		IObservable observable = delegate.createObservable();
		ensureStale(observable, false);

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

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

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

		StaleEvent event;

		boolean isCurrentRealm;

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

}




/*******************************************************************************
 * Copyright (c) 2007 Brad Reynolds and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Brad Reynolds - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.conformance.databinding;

import junit.framework.TestCase;

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.Realm;

/**
 * TestCase that asserts the conformance of an observable to the defined
 * contract for changes.
 * 
 * @since 3.2
 */
public class ObservableContractTests extends TestCase {
	private Realm previousRealm;

	private IObservableContractDelegate delegate;

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

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

		previousRealm = Realm.getDefault();
		delegate.setUp();
	}

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

		delegate.tearDown();
		DummyRealm.setDefaultRealm(previousRealm);
	}

	public void testRealmIsNotNull() throws Exception {
		IObservable observable = delegate.createObservable();

		assertNotNull("The observable's realm should not be null.", observable.getRealm());
	}

	public void testChangeFiresChangeEvent() throws Exception {
		ChangeListener listener = new ChangeListener();
		IObservable observable = delegate.createObservable();

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

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

	public void testChangeEventObservable() throws Exception {
		ChangeListener listener = new ChangeListener();
		IObservable observable = delegate.createObservable();

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

		ChangeEvent event = listener.event;
		assertNotNull("change event was null", event);
		
		assertSame("In the change event the source of the change should be the observable.", observable,
				event.getObservable());
	}

	public void testObservableRealmIsTheCurrentRealmOnChange() throws Exception {
		IObservable observable = delegate.createObservable();
		ChangeListener listener = new ChangeListener();
		observable.addChangeListener(listener);

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

	public void testRemoveChangeListenerRemovesListener() throws Exception {
		ChangeListener listener = new ChangeListener();
		IObservable observable = delegate.createObservable();

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

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

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

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

	public void testIsNotStale() throws Exception {
		IObservable observable = delegate.createObservable();

		delegate.setStale(observable, false);
		assertFalse("When an observable is not stale isStale() should return false.", observable.isStale());
	}

	/**
	 * Workaround to be able to set the default realm outside a runnable. The
	 * setDefaultRealm(...) method is the only usable method.
	 * 
	 * @since 3.2
	 */
	/* package */static class DummyRealm extends Realm {
		/**
		 * Can't be instantiated.
		 */
		private DummyRealm() {
		}

		static void setDefaultRealm(Realm realm) {
			setDefault(realm);
		}

		public boolean isCurrent() {
			throw new UnsupportedOperationException();
		}
	}

	/* package */static class ChangeListener implements IChangeListener {
		int count;

		ChangeEvent event;

		boolean isCurrentRealm;

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




/*******************************************************************************
 * Copyright (c) 2007 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.value.IObservableValue;

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

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

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




/*******************************************************************************
 * Copyright (c) 2007 Brad Reynolds and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Brad Reynolds - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.conformance.databinding;

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

/**
 * Delegate interface for an observable value.
 * 
 * <p>
 * Do not directly implement this interface. Please extend
 * {@link AbstractObservableValueContractDelegate} instead.
 * </p>
 * 
 * @since 1.1
 */
public interface IObservableValueContractDelegate extends
		IObservableContractDelegate {

	/**
	 * Creates a new observable value.
	 * 
	 * @return observable value
	 */
	IObservableValue createObservableValue();

	/**
	 * Returns the expected type of the observable.
	 * 
	 * @param observable
	 * @return type
	 */
	Object getValueType(IObservableValue observable);
}




/*******************************************************************************
 * Copyright (c) 2007 Brad Reynolds and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Brad Reynolds - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.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.IObservable;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.observable.value.IValueChangeListener;
import org.eclipse.core.databinding.observable.value.ValueChangeEvent;

/**
 * @since 3.2
 */
public class ObservableValueContractTests extends ObservableContractTests {

	private IObservableValueContractDelegate delegate;

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

	/**
	 * @param testName
	 * @param delegate
	 */
	public ObservableValueContractTests(String testName,
			IObservableValueContractDelegate delegate) {
		super(testName, delegate);

		this.delegate = delegate;
	}

	public void testChangeNotifiesValueChangeListeners() throws Exception {
		IObservableValue observable = delegate.createObservableValue();
		ValueChangeListener listener = new ValueChangeListener(observable)
				.init();

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

	public void testSettingSameValueDoesNotNotifiyValueChangeListeners()
			throws Exception {
		IObservableValue observable = delegate.createObservableValue();
		delegate.change(observable);

		ValueChangeListener listener = new ValueChangeListener(observable)
				.init();
		Object value = observable.getValue();
		observable.setValue(value);

		assertEquals(
				"When the current value is set on the observable a change does not occur thus value change listeners should not be notified.",
				0, listener.count);
	}

	public void testSettingSameValueDoesNotNotifyChangeListeners()
			throws Exception {
		IObservableValue observable = delegate.createObservableValue();
		delegate.change(observable);

		ChangeListener listener = new ChangeListener(observable).init();
		Object value = observable.getValue();
		observable.setValue(value);

		assertEquals(
				"When the current value is set on the observable a change does not occur thus change listeners should not be notified.",
				0, listener.count);
	}

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

	public void testChangeListenersAreNotifiedBeforeValueChangeListeners()
			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);
			}
		};

		IObservableValue observable = delegate.createObservableValue();
		observable.addChangeListener(changeListener);
		observable.addValueChangeListener(valueChangeListener);

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

	public void testValueChangeEventOldValueIsPreviousValue() throws Exception {
		IObservableValue observable = delegate.createObservableValue();
		ValueChangeListener listener = new ValueChangeListener(observable)
				.init();
		Object oldValue = observable.getValue();

		delegate.change(observable);

		ValueChangeEvent event = listener.event;
		assertEquals(
				"When a value change event is fired the old value should be the previous value of the observable value.",
				oldValue, event.diff.getOldValue());
	}

	public void testValueChangeEventObservableValue() throws Exception {
		IObservableValue observable = delegate.createObservableValue();
		ValueChangeListener listener = new ValueChangeListener(observable)
				.init();
		delegate.change(observable);

		ValueChangeEvent event = listener.event;
		assertEquals(
				"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 testRemoveValueChangeListenerRemovesListener() throws Exception {
		IObservableValue observable = delegate.createObservableValue();
		ValueChangeListener listener = new ValueChangeListener(observable)
				.init();
		delegate.change(observable);

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

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

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

	/* package */static class ChangeListener implements IChangeListener {
		int count;

		IObservable observable;

		ChangeListener(IObservable observable) {
			this.observable = observable;
		}

		ChangeListener init() {
			observable.addChangeListener(this);
			return this;
		}

		public void handleChange(ChangeEvent event) {
			count++;
		}
	}

	/* package */static class ValueChangeListener implements
			IValueChangeListener {
		int count;

		ValueChangeEvent event;

		private IObservableValue observable;

		ValueChangeListener(IObservableValue observable) {
			this.observable = observable;
		}

		ValueChangeListener init() {
			observable.addValueChangeListener(this);
			return this;
		}

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




/*******************************************************************************
 * Copyright (c) 2007 Brad Reynolds and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Brad Reynolds - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.conformance.databinding;

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

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

	public void setUp() {
		// no op
	}

	public void tearDown() {
		// no op
	}

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

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




/*******************************************************************************
 * Copyright (c) 2007 Brad Reynolds and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Brad Reynolds - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.conformance.databinding;

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

/**
 * Delegate interface for observables.
 * 
 * <p>
 * Do not directly implement this interface. Please extend
 * {@link AbstractObservableContractDelegate} instead.
 * </p>
 * 
 * @since 1.1
 */
public interface IObservableContractDelegate {
	/**
	 * Notifies the delegate of the start of a test.
	 */
	void setUp();

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

	/**
	 * Invokes an operation to set the stale state to the provided value.
	 * 
	 * @param observable
	 * @param stale
	 */
	void setStale(IObservable observable, boolean stale);

	/**
	 * Creates a new observable.
	 * 
	 * @return observable
	 */
	public IObservable createObservable();

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

Return to bug 182059

Lines 11-18 Link Here

(-)src/org/eclipse/jface/tests/internal/databinding/internal/swt/ButtonObservableValueTest.java (-14 / +48 lines)
11		11
12	package org.eclipse.jface.tests.internal.databinding.internal.swt;	12	package org.eclipse.jface.tests.internal.databinding.internal.swt;
13		13
		14	import junit.framework.Test;
14	import junit.framework.TestCase;	15	import junit.framework.TestCase;
		16	import junit.framework.TestSuite;
15		17
		18	import org.eclipse.core.databinding.observable.IObservable;
		19	import org.eclipse.core.databinding.observable.value.IObservableValue;
		20	import org.eclipse.jface.conformance.databinding.AbstractObservableValueContractDelegate;
		21	import org.eclipse.jface.conformance.databinding.ObservableValueContractTests;
		22	import org.eclipse.jface.conformance.databinding.SuiteBuilder;
16	import org.eclipse.jface.internal.databinding.internal.swt.ButtonObservableValue;	23	import org.eclipse.jface.internal.databinding.internal.swt.ButtonObservableValue;
17	import org.eclipse.swt.SWT;	24	import org.eclipse.swt.SWT;
18	import org.eclipse.swt.widgets.Button;	25	import org.eclipse.swt.widgets.Button;
Lines 20-39 Link Here
20		27
21	/**	28	/**
22	* @since 3.2	29	* @since 3.2
23	*
24	*/	30	*/
25	public class ButtonObservableValueTest extends TestCase {	31	public class ButtonObservableValueTest extends TestCase {
26	public void testSetValue() throws Exception {	32	public static Test suite() {
27	Shell shell = new Shell();	33	TestSuite suite = new TestSuite();
28	Button button = new Button(shell, SWT.CHECK);	34	Object[] params = new Object[] { new Delegate() };
29	ButtonObservableValue observableValue = new ButtonObservableValue(button);	35
30	assertEquals(Boolean.FALSE, observableValue.getValue());	36	SuiteBuilder
31	assertFalse(button.getSelection());	37	.forSuite(suite)
32		38	.addParameterizedTests(ObservableValueContractTests.class, params);
33	Boolean value = Boolean.TRUE;	39
34	observableValue.setValue(value);	40	return suite;
35	assertTrue("button value", button.getSelection());	41	}
36	assertEquals("observable value", value, observableValue.getValue());	42
37	shell.dispose();	43	/* package */ static class Delegate extends AbstractObservableValueContractDelegate {
		44	Shell shell;
		45	Button button;
		46
		47	public void setUp() {
		48	super.setUp();
		49
		50	shell = new Shell();
		51	button = new Button(shell, SWT.CHECK);
		52	}
		53
		54	public void tearDown() {
		55	super.tearDown();
		56
		57	shell.dispose();
		58	}
		59
		60	public IObservableValue createObservableValue() {
		61	return new ButtonObservableValue(button);
		62	}
		63
		64	public Object getValueType(IObservableValue observable) {
		65	return Boolean.TYPE;
		66	}
		67
		68	public void change(IObservable observable) {
		69	button.setSelection(!button.getSelection());
		70	button.notifyListeners(SWT.Selection, null);
		71	}
38	}	72	}
39	}	73	}

Lines 147-153 Link Here

(-)src/org/eclipse/jface/tests/databinding/BindingTestSuite.java (-3 / +5 lines)
147	addTestSuite(StringToNumberConverterTest.class);	147	addTestSuite(StringToNumberConverterTest.class);
148		148
149	// org.eclipse.core.tests.databinding.observable	149	// org.eclipse.core.tests.databinding.observable
150	addTestSuite(AbstractObservableTest.class);	150	addTest(AbstractObservableTest.suite());
151	addTestSuite(Diffs_ListDiffTests.class);	151	addTestSuite(Diffs_ListDiffTests.class);
152	addTestSuite(DiffsTest.class);	152	addTestSuite(DiffsTest.class);
153	addTestSuite(ObservablesTest.class);	153	addTestSuite(ObservablesTest.class);
Lines 174-180 Link Here
174	addTestSuite(AbstractObservableValueTest.class);	174	addTestSuite(AbstractObservableValueTest.class);
175	addTestSuite(AbstractVetoableValueTest.class);	175	addTestSuite(AbstractVetoableValueTest.class);
176	addTestSuite(ComputedValueTest.class);	176	addTestSuite(ComputedValueTest.class);
177	addTestSuite(WritableValueTest.class);	177	addTest(WritableValueTest.suite());
		178	// addTestSuite(WritableValueTest.class);
178		179
179	//org.eclipse.core.tests.databinding.validation	180	//org.eclipse.core.tests.databinding.validation
180	addTestSuite(ValidationStatusTest.class);	181	addTestSuite(ValidationStatusTest.class);
Lines 261-267 Link Here
261	addTestSuite(EditMaskParserTest.class);	262	addTestSuite(EditMaskParserTest.class);
262		263
263	//org.eclipse.jface.tests.internal.databinding.internal.swt	264	//org.eclipse.jface.tests.internal.databinding.internal.swt
264	addTestSuite(ButtonObservableValueTest.class);	265	addTest(ButtonObservableValueTest.suite());
		266	// addTestSuite(ButtonObservableValueTest.class);
265	addTestSuite(CComboObservableValueTest.class);	267	addTestSuite(CComboObservableValueTest.class);
266	addTestSuite(CLabelObservableValueTest.class);	268	addTestSuite(CLabelObservableValueTest.class);
267	addTestSuite(ComboObservableValueTest.class);	269	addTestSuite(ComboObservableValueTest.class);

Added Link Here

(-)src/org/eclipse/jface/conformance/databinding/SuiteBuilder.java (+138 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 Brad Reynolds and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Brad Reynolds - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.jface.conformance.databinding;
13
14	import java.lang.reflect.Constructor;
15	import java.lang.reflect.Method;
16
17	import junit.framework.Test;
18	import junit.framework.TestSuite;
19
20	/**
21	* Builds a test suite.
22	*
23	* @since 1.1
24	*/
25	// TODO remove the forSuite(...) method and add a toSuite() method that returns
26	// a new TestSuite.
27	public class SuiteBuilder {
28	private TestSuite suite;
29
30	private SuiteBuilder(TestSuite suite) {
31	// prohibit public construction
32	this.suite = suite;
33	}
34
35	/**
36	* Adds all test methods from the provided <code>testCase</code> to the
37	* suite.
38	*
39	* @param testCase
40	* @return builder
41	*/
42	public SuiteBuilder addTests(Class testCase) {
43	suite.addTestSuite(testCase);
44	return this;
45	}
46
47	/**
48	* Adds all test methods from the provided <code>testCase</code> with the
49	* provided <code>parameters</code>. A constructor must exist in the
50	* testCase that accepts a String as the first parameter followed by
51	* parameters matching the provided parameters. If an appropriate
52	* constructor is not found an exception will be thrown.
53	*
54	* @param testCase
55	* @param parameters
56	* @return builder
57	*/
58	public SuiteBuilder addParameterizedTests(Class testCase,
59	Object[] parameters) {
60	Method[] methods = testCase.getMethods();
61
62	Constructor constructor = findConstructor(testCase, parameters);
63	if (constructor == null) {
64	throw new IllegalArgumentException(
65	"The parameters provided don't match a constructor found in ["
66	+ testCase.getName() + "]");
67	}
68
69	for (int i = 0; i < methods.length; i++) {
70	String name = methods[i].getName();
71	if (name.startsWith("test")) {
72	try {
73	suite.addTest((Test) constructor.newInstance(toParamArray(
74	name, parameters)));
75	} catch (Exception e) {
76	throw new RuntimeException(e);
77	}
78	}
79	}
80
81	return this;
82	}
83
84	private Object[] toParamArray(String testName, Object[] parameters) {
85	Object[] result = new Object[parameters.length + 1];
86	result[0] = testName;
87	System.arraycopy(parameters, 0, result, 1, parameters.length);
88	return result;
89	}
90
91	/**
92	* Returns the constructor that has a String as the first parameters and
93	* then matches the type of the parameters.
94	*
95	* @param parameters
96	* @return
97	*/
98	private static Constructor findConstructor(Class clazz, Object[] parameters) {
99	Constructor[] constructors = clazz.getConstructors();
100	int expectedParametersLength = parameters.length + 1;
101
102	for (int i = 0; i < constructors.length; i++) {
103	Constructor constructor = constructors[i];
104	Class[] types = constructor.getParameterTypes();
105
106	if (types.length != expectedParametersLength
107	\|\| !String.class.equals(types[i])) {
108	continue;
109	}
110
111	boolean skip = false;
112	for (int j = 1; j < types.length; j++) {
113	Class type = types[j];
114	if (!type.isInstance(parameters[j - 1])) {
115	skip = true;
116	break;
117	}
118	}
119
120	if (!skip) {
121	return constructor;
122	}
123	}
124
125	return null;
126	}
127
128	public static SuiteBuilder forSuite(TestSuite suite) {
129	return new SuiteBuilder(suite);
130	}
131
132	/* package */static class UniqueTest {
133	/* package */UniqueTest(Class clazz, String testName,
134	Object[] parameters) {
135
136	}
137	}
138	}