Attachment #117279 for bug #246103

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

View | Details | Raw Unified | Return to bug 246103
Collapse All | Expand All




 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Brad Reynolds - bug 164653
 *     Matthew Hall - bugs 118516, 146397, 226289, 246103
 *******************************************************************************/

package org.eclipse.core.databinding.observable.map;

public abstract class AbstractObservableMap extends AbstractMap implements
		IObservableMap {

	private final class PrivateChangeSupport extends ChangeSupport {
		private PrivateChangeSupport(Realm realm) {
			super(realm);
		}

		protected void firstListenerAdded() {
			AbstractObservableMap.this.firstListenerAdded();
		}

		protected void lastListenerRemoved() {
			AbstractObservableMap.this.lastListenerRemoved();
		}

		protected boolean hasListeners() {
			return super.hasListeners();
		}
	}

	private PrivateChangeSupport changeSupport;
	private boolean disposed = false;

	private boolean stale;

	 */
	public AbstractObservableMap(Realm realm) {
		Assert.isNotNull(realm, "Realm cannot be null"); //$NON-NLS-1$
		changeSupport = new PrivateChangeSupport(realm);
			protected void firstListenerAdded() {
				AbstractObservableMap.this.firstListenerAdded();
			}
			protected void lastListenerRemoved() {
				AbstractObservableMap.this.lastListenerRemoved();
			}
		};
	}

	public synchronized void addMapChangeListener(IMapChangeListener listener) {

	}

	/**
	 * @return whether the observable map has listeners registered
	 * @since 1.2
	 */
	protected synchronized boolean hasListeners() {
		return !disposed && changeSupport.hasListeners();
	}

	/**
	 * @since 1.2
	 */
	public void addDisposeListener(IDisposeListener listener) {




 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Matthew Hall - bugs 213145, 241585, 246103
 *******************************************************************************/

package org.eclipse.core.tests.internal.databinding.beans;

import java.beans.PropertyDescriptor;
import java.util.Collections;
import java.util.HashSet;

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

import org.eclipse.core.databinding.beans.BeansObservables;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.map.IMapChangeListener;
import org.eclipse.core.databinding.observable.map.IObservableMap;
import org.eclipse.core.databinding.observable.map.MapChangeEvent;
import org.eclipse.core.databinding.observable.map.MapDiff;
import org.eclipse.core.databinding.observable.set.WritableSet;

import org.eclipse.core.tests.databinding.observable.ThreadRealm;
import org.eclipse.jface.databinding.conformance.util.ChangeEventTracker;
import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
import org.eclipse.jface.databinding.conformance.util.MapChangeEventTracker;

/**
 * @since 3.2

		assertTrue(bean.hasListeners("value"));
	}

	public void testSetBeanProperty_CorrectForNullOldAndNewValues() {
		// The java bean spec allows the old and new values in a
		// PropertyChangeEvent to be null, which indicates that an unknown
		// change occured.

		// This test ensures that JavaBeanObservableValue fires the correct
		// value diff even if the bean implementor is lazy :-P

		WritableSet set = new WritableSet(new CurrentRealm(true));

		Bean bean = new AnnoyingBean();
		bean.setValue("old");
		set.add(bean);

		IObservableMap map = BeansObservables.observeMap(set, Bean.class,
				"value");
		MapChangeEventTracker tracker = MapChangeEventTracker.observe(map);

		bean.setValue("new");

		assertEquals(1, tracker.count);

		assertEquals(Collections.EMPTY_SET, tracker.event.diff.getAddedKeys());
		assertEquals(Collections.singleton(bean), tracker.event.diff
				.getChangedKeys());
		assertEquals(Collections.EMPTY_SET, tracker.event.diff.getRemovedKeys());

		assertEquals("old", tracker.event.diff.getOldValue(bean));
		assertEquals("new", tracker.event.diff.getNewValue(bean));
	}

	private static class MapChangeListener implements IMapChangeListener {
		int count;





 *     Brad Reynolds - initial API and implementation
 *     Brad Reynolds - bug 171616
 *     Katarzyna Marszalek - test case for bug 198519
 *     Matthew Hall - bug 213145, 246103
 ******************************************************************************/

package org.eclipse.core.tests.internal.databinding.beans;

import org.eclipse.jface.databinding.conformance.MutableObservableValueContractTest;
import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
import org.eclipse.jface.databinding.conformance.util.ChangeEventTracker;
import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;
import org.eclipse.jface.examples.databinding.model.SimplePerson;
import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;


		assertFalse(bean.hasListeners(propertyName));
	}
	
	public void testSetBeanProperty_CorrectForNullOldAndNewValues() {
		// The java bean spec allows the old and new values in a PropertyChangeEvent to
		// be null, which indicates that an unknown change occured.

		// This test ensures that JavaBeanObservableValue fires the correct value diff
		// even if the bean implementor is lazy :-P

		Bean bean = new AnnoyingBean();
		bean.setValue("old");
		IObservableValue observable = BeansObservables.observeValue(bean, "value");
		ValueChangeEventTracker tracker = ValueChangeEventTracker.observe(observable);
		bean.setValue("new");
		assertEquals(1, tracker.count);
		assertEquals("old", tracker.event.diff.getOldValue());
		assertEquals("new", tracker.event.diff.getNewValue());
	}

	public static Test suite() {
		TestSuite suite = new TestSuite(JavaBeanObservableValueTest.class.getName());
		suite.addTestSuite(JavaBeanObservableValueTest.class);




 *
 * Contributors:
 *     Brad Reynolds - initial API and implementation
 *     Matthew Hall - bugs 221351, 213145, 244098, 246103
 ******************************************************************************/

package org.eclipse.core.tests.internal.databinding.beans;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyDescriptor;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

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

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

import org.eclipse.core.internal.databinding.beans.JavaBeanObservableList;
import org.eclipse.jface.databinding.conformance.MutableObservableListContractTest;
import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableCollectionContractDelegate;
import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
import org.eclipse.jface.databinding.conformance.util.ListChangeEventTracker;
import org.eclipse.jface.databinding.swt.SWTObservables;
import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;

		assertEquals(1, listener.count);
	}

	public void testSetBeanProperty_CorrectForNullOldAndNewValues() {
		// The java bean spec allows the old and new values in a
		// PropertyChangeEvent to be null, which indicates that an unknown
		// change occured.

		// This test ensures that JavaBeanObservableValue fires the correct
		// value diff even if the bean implementor is lazy :-P

		Bean bean = new AnnoyingBean();
		bean.setArray(new Object[] { "old" });
		IObservableList observable = BeansObservables.observeList(
				new CurrentRealm(true), bean, "array");
		ListChangeEventTracker tracker = ListChangeEventTracker
				.observe(observable);
		bean.setArray(new Object[] { "new" });
		assertEquals(1, tracker.count);

		List list = new ArrayList();
		list.add("old");
		tracker.event.diff.applyTo(list);
		assertEquals(Collections.singletonList("new"), list);
	}

	private static void assertEntry(ListDiffEntry entry, boolean addition,
			int position, Object element) {
		assertEquals("addition", addition, entry.isAddition());




 *
 * Contributors:
 *     Brad Reynolds - initial API and implementation
 *     Matthew Hall - bugs 221351, 213145, 244098, 246103
 ******************************************************************************/

package org.eclipse.core.tests.internal.databinding.beans;

import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;

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

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

import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableCollectionContractDelegate;
import org.eclipse.jface.databinding.conformance.util.ChangeEventTracker;
import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
import org.eclipse.jface.databinding.conformance.util.SetChangeEventTracker;
import org.eclipse.jface.databinding.swt.SWTObservables;
import org.eclipse.swt.widgets.Display;


		ChangeEventTracker.observe(observableSet);
		assertFalse(bean.hasListeners(propertyName));
	}

	public void testSetBeanProperty_CorrectForNullOldAndNewValues() {
		// The java bean spec allows the old and new values in a
		// PropertyChangeEvent to be null, which indicates that an unknown
		// change occured.

		// This test ensures that JavaBeanObservableValue fires the correct
		// value diff even if the bean implementor is lazy :-P

		Bean bean = new AnnoyingBean();
		bean.setSet(Collections.singleton("old"));
		IObservableSet observable = BeansObservables.observeSet(
				new CurrentRealm(true), bean, "set");
		SetChangeEventTracker tracker = SetChangeEventTracker
				.observe(observable);
		bean.setSet(Collections.singleton("new"));
		assertEquals(1, tracker.count);
		assertEquals(Collections.singleton("old"), tracker.event.diff
				.getRemovals());
		assertEquals(Collections.singleton("new"), tracker.event.diff
				.getAdditions());
	}

	static class SetChangeListener implements ISetChangeListener {
		int count;
		public void handleSetChange(SetChangeEvent event) {




import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**

 * @since 3.3
 */
public class Bean {
	protected PropertyChangeSupport changeSupport = new PropertyChangeSupport(
			this);
	protected String value;
	protected Object[] array;
	protected List list;
	protected Set set;
	protected Map map;

	public Bean() {
	}

		this.set = set;
	}

	public Bean(Map map) {
		this.map = map;
	}

	public void addPropertyChangeListener(PropertyChangeListener listener) {
		changeSupport.addPropertyChangeListener(listener);
	}

		changeSupport.firePropertyChange("set", this.set, this.set = set);
	}

	public Map getMap() {
		return map;
	}

	public void setMap(Map map) {
		changeSupport.firePropertyChange("map", this.map, this.map = map);
	}

	public boolean hasListeners(String propertyName) {
		return changeSupport.hasListeners(propertyName);
	}




 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 221351)
 *     Brad Reynolds - through JavaBeanObservableArrayBasedListTest.java
 *     Matthew Hall - bug 213145, 244098, 246103
 ******************************************************************************/

package org.eclipse.core.tests.internal.databinding.beans;

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

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

import org.eclipse.core.internal.databinding.beans.JavaBeanObservableSet;
import org.eclipse.jface.databinding.conformance.MutableObservableSetContractTest;
import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableCollectionContractDelegate;
import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
import org.eclipse.jface.databinding.conformance.util.SetChangeEventTracker;
import org.eclipse.jface.databinding.swt.SWTObservables;
import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;

		assertEquals(0, bean.getArray().length);
	}

	public void testRemove_SetChangeEvent() throws Exception {
		String element = "1";
		set.add(element);
		assertEquals(1, set.size());

		assertEquals(2, bean.getArray().length);
	}

	public void testAddAll_SetChangeEvent() throws Exception {
		Collection elements = Arrays.asList(new String[] { "1", "2" });
		assertEquals(0, set.size());


		assertEquals(0, bean.getArray().length);
	}

	public void testRemoveAll_SetChangeEvent() throws Exception {
		Collection elements = Arrays.asList(new String[] { "1", "2" });
		set.addAll(elements);


		assertTrue(set.containsAll(Arrays.asList(new String[] { "1", "0" })));
	}

	public void testRetainAll_SetChangeEvent() throws Exception {
		set.addAll(Arrays.asList(new String[] { "0", "1", "2", "3" }));

		SetChangeEventTracker listener = SetChangeEventTracker.observe(set);

		});
	}

	public void testSetChangeEventFiresWhenNewSetIsSet() throws Exception {
		Bean[] elements = new Bean[] { new Bean(), new Bean() };

		SetChangeEventTracker listener = SetChangeEventTracker.observe(set);

		assertEquals(1, listener.count);
	}

	public void testSetBeanProperty_CorrectForNullOldAndNewValues() {
		// The java bean spec allows the old and new values in a
		// PropertyChangeEvent to be null, which indicates that an unknown
		// change occured.

		// This test ensures that JavaBeanObservableValue fires the correct
		// value diff even if the bean implementor is lazy :-P

		Bean bean = new AnnoyingBean();
		bean.setArray(new Object[] { "old" });
		IObservableSet observable = BeansObservables.observeSet(
				new CurrentRealm(true), bean, "array");
		SetChangeEventTracker tracker = SetChangeEventTracker
				.observe(observable);
		bean.setArray(new Object[] { "new" });
		assertEquals(1, tracker.count);
		assertEquals(Collections.singleton("old"), tracker.event.diff
				.getRemovals());
		assertEquals(Collections.singleton("new"), tracker.event.diff
				.getAdditions());
	}

	private static void assertPropertyChangeEvent(Bean bean, Runnable runnable) {
		PropertyChangeTracker listener = new PropertyChangeTracker();
		bean.addPropertyChangeListener(listener);

		assertTrue("old value", Arrays.equals(old, (Object[]) event
				.getOldValue()));
		assertTrue("new value", Arrays.equals(bean.getArray(), (Object[]) event.getNewValue()));
		assertFalse("sets are equal", Arrays.equals(bean.getArray(), old));
	}

	private static class PropertyChangeTracker implements

			}
			Object bean = new Bean(new Object[0]);

			IObservableSet set = new JavaBeanObservableSet(realm, bean,
					propertyDescriptor, String.class);
			for (int i = 0; i < elementCount; i++)
				set.add(createElement(set));
			return set;
		}

		public Object createElement(IObservableCollection collection) {

		}

		public void change(IObservable observable) {
			IObservableSet set = (IObservableSet) observable;
			set.add(createElement(set));
		}
	}
}




 *
 * Contributors:
 *     Brad Reynolds - initial API and implementation
 *     Matthew Hall - bugs 221351, 213145, 244098, 246103
 ******************************************************************************/

package org.eclipse.core.tests.internal.databinding.beans;

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

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

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

import org.eclipse.jface.databinding.conformance.MutableObservableListContractTest;
import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableCollectionContractDelegate;
import org.eclipse.jface.databinding.conformance.util.ChangeEventTracker;
import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
import org.eclipse.jface.databinding.conformance.util.ListChangeEventTracker;
import org.eclipse.jface.databinding.swt.SWTObservables;
import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;

		assertFalse(bean.hasListeners("list"));
	}

	public void testSetBeanProperty_CorrectForNullOldAndNewValues() {
		// The java bean spec allows the old and new values in a
		// PropertyChangeEvent to be null, which indicates that an unknown
		// change occured.

		// This test ensures that JavaBeanObservableValue fires the correct
		// value diff even if the bean implementor is lazy :-P

		Bean bean = new AnnoyingBean();
		bean.setList(Collections.singletonList("old"));
		IObservableList observable = BeansObservables.observeList(
				new CurrentRealm(true), bean, "list");
		ListChangeEventTracker tracker = ListChangeEventTracker
				.observe(observable);
		bean.setList(Collections.singletonList("new"));

		assertEquals(1, tracker.count);
		
		List list = new ArrayList();
		list.add("old");
		tracker.event.diff.applyTo(list);
		assertEquals(Collections.singletonList("new"), list);
	}

	private static void assertEntry(ListDiffEntry entry, boolean addition,
			int position, Object element) {
		assertEquals("addition", addition, entry.isAddition());




 *     Ashley Cambrell - bugs 198903, 198904
 *     Matthew Hall - bugs 210115, 212468, 212223, 206839, 208858, 208322,
 *                    212518, 215531, 221351, 184830, 213145, 218269, 239015,
 *                    237703, 237718, 222289, 247394, 233306, 247647, 246103
 *     Ovidio Mallo - bug 237163, bug 235195
 *******************************************************************************/
package org.eclipse.jface.tests.databinding;

import org.eclipse.core.tests.internal.databinding.beans.JavaBeanObservableMapTest;
import org.eclipse.core.tests.internal.databinding.beans.JavaBeanObservableSetTest;
import org.eclipse.core.tests.internal.databinding.beans.JavaBeanObservableValueTest;
import org.eclipse.core.tests.internal.databinding.beans.JavaBeanPropertyObservableMapTest;
import org.eclipse.core.tests.internal.databinding.beans.ListenerSupportTest;
import org.eclipse.core.tests.internal.databinding.conversion.DateConversionSupportTest;
import org.eclipse.core.tests.internal.databinding.conversion.IdentityConverterTest;

		addTest(JavaBeanObservableMapTest.suite());
		addTest(JavaBeanObservableSetTest.suite());
		addTest(JavaBeanObservableValueTest.suite());
		addTestSuite(JavaBeanPropertyObservableMapTest.class);
		addTestSuite(ListenerSupportTest.class);
		
		//org.eclipse.core.tests.internal.databinding.observable




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall 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:
 *     Matthew Hall - initial API and implementation (bug 246103)
 ******************************************************************************/

package org.eclipse.core.tests.internal.databinding.beans;

import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * A bean in which all property change events are fired according to an annoying
 * provision in the bean spec, where <code>(oldValue == null && newValue ==
 * null)</code> indicates that an unknown change occured.
 * 
 * @since 3.2
 */
public class AnnoyingBean extends Bean {
	public void setValue(String value) {
		this.value = value;
		changeSupport.firePropertyChange("value", null, null);
	}

	public void setArray(Object[] array) {
		this.array = array;
		changeSupport.firePropertyChange("array", null, null);
	}

	public void setList(List list) {
		this.list = list;
		changeSupport.firePropertyChange("list", null, null);
	}

	public void setSet(Set set) {
		this.set = set;
		changeSupport.firePropertyChange("set", null, null);
	}

	public void setMap(Map map) {
		this.map = map;
		changeSupport.firePropertyChange("map", null, null);
	}
}

/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall 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:
 *     Matthew Hall - initial API and implementation (bug 246103)
 ******************************************************************************/

package org.eclipse.core.tests.internal.databinding.beans;

import java.util.Collections;

import org.eclipse.core.databinding.beans.BeansObservables;
import org.eclipse.core.databinding.observable.map.IObservableMap;
import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
import org.eclipse.jface.databinding.conformance.util.MapChangeEventTracker;
import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;

/**
 * @since 3.2
 * 
 */
public class JavaBeanPropertyObservableMapTest extends
		AbstractDefaultRealmTestCase {
	public void testSetBeanProperty_CorrectForNullOldAndNewValues() {
		// The java bean spec allows the old and new values in a
		// PropertyChangeEvent to be null, which indicates that an unknown
		// change occured.

		// This test ensures that JavaBeanObservableValue fires the correct
		// value diff even if the bean implementor is lazy :-P

		Bean bean = new AnnoyingBean();
		bean.setMap(Collections.singletonMap("key", "old"));

		IObservableMap map = BeansObservables.observeMap(
				new CurrentRealm(true), bean, "map");
		MapChangeEventTracker tracker = MapChangeEventTracker.observe(map);

		bean.setMap(Collections.singletonMap("key", "new"));

		assertEquals(1, tracker.count);

		assertEquals(Collections.EMPTY_SET, tracker.event.diff.getAddedKeys());
		assertEquals(Collections.singleton("key"), tracker.event.diff
				.getChangedKeys());
		assertEquals(Collections.EMPTY_SET, tracker.event.diff.getRemovedKeys());

		assertEquals("old", tracker.event.diff.getOldValue("key"));
		assertEquals("new", tracker.event.diff.getNewValue("key"));
	}

}

Lines 8-14 Link Here

(-)src/org/eclipse/core/internal/databinding/beans/JavaBeanObservableMap.java (-7 / +59 lines)
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Brad Reynolds - bug 171616	10	* Brad Reynolds - bug 171616
11	* Matthew hall - bugs 223164, 241585, 226289	11	* Matthew hall - bugs 223164, 241585, 226289, 246103
12	*******************************************************************************/	12	*******************************************************************************/
13		13
14	package org.eclipse.core.internal.databinding.beans;	14	package org.eclipse.core.internal.databinding.beans;
Lines 16-27 Link Here
16	import java.beans.PropertyChangeListener;	16	import java.beans.PropertyChangeListener;
17	import java.beans.PropertyDescriptor;	17	import java.beans.PropertyDescriptor;
18	import java.lang.reflect.Method;	18	import java.lang.reflect.Method;
		19	import java.util.HashMap;
		20	import java.util.Map;
19		21
20	import org.eclipse.core.databinding.beans.IBeanObservable;	22	import org.eclipse.core.databinding.beans.IBeanObservable;
21	import org.eclipse.core.databinding.observable.Diffs;	23	import org.eclipse.core.databinding.observable.Diffs;
22	import org.eclipse.core.databinding.observable.map.ComputedObservableMap;	24	import org.eclipse.core.databinding.observable.map.ComputedObservableMap;
23	import org.eclipse.core.databinding.observable.set.IObservableSet;	25	import org.eclipse.core.databinding.observable.set.IObservableSet;
24	import org.eclipse.core.databinding.util.Policy;	26	import org.eclipse.core.databinding.util.Policy;
		27	import org.eclipse.core.internal.databinding.Util;
25	import org.eclipse.core.runtime.IStatus;	28	import org.eclipse.core.runtime.IStatus;
26	import org.eclipse.core.runtime.Status;	29	import org.eclipse.core.runtime.Status;
27		30
Lines 39-47 Link Here
39	if (!updating) {	42	if (!updating) {
40	getRealm().exec(new Runnable() {	43	getRealm().exec(new Runnable() {
41	public void run() {	44	public void run() {
42	fireMapChange(Diffs.createMapDiffSingleChange(	45	Object source = event.getSource();
43	event.getSource(), event.getOldValue(), event	46	Object oldValue = event.getOldValue();
44	.getNewValue()));	47	Object newValue = event.getNewValue();
		48	if (oldValue == null && newValue == null) {
		49	oldValue = cachedValues.get(new IdentityWrapper(
		50	source));
		51	newValue = doGet(source);
		52	}
		53	cachedValues.put(new IdentityWrapper(source), newValue);
		54	if (!Util.equals(oldValue, newValue)) {
		55	fireMapChange(Diffs.createMapDiffSingleChange(
		56	source, oldValue, newValue));
		57	}
45	}	58	}
46	});	59	});
47	}	60	}
Lines 54-59 Link Here
54		67
55	private boolean attachListeners;	68	private boolean attachListeners;
56		69
		70	// Applicable only while hasListeners() == true
		71	private Map cachedValues;
		72
57	/**	73	/**
58	* @param domain	74	* @param domain
59	* @param propertyDescriptor	75	* @param propertyDescriptor
Lines 80-93 Link Here
80	}	96	}
81	}	97	}
82		98
		99	protected void firstListenerAdded() {
		100	if (attachListeners) {
		101	cachedValues = new HashMap();
		102	}
		103	super.firstListenerAdded();
		104	}
		105
		106	protected void lastListenerRemoved() {
		107	super.lastListenerRemoved();
		108	if (attachListeners) {
		109	cachedValues = null;
		110	}
		111	}
		112
83	protected void hookListener(Object domainElement) {	113	protected void hookListener(Object domainElement) {
84	if (attachListeners && domainElement != null) {	114	if (attachListeners && domainElement != null) {
85	listenerSupport.hookListener(domainElement);	115	listenerSupport.hookListener(domainElement);
		116	cachedValues.put(new IdentityWrapper(domainElement),
		117	doGet(domainElement));
86	}	118	}
87	}	119	}
88		120
89	protected void unhookListener(Object domainElement) {	121	protected void unhookListener(Object domainElement) {
90	if (attachListeners && domainElement != null) {	122	if (attachListeners && domainElement != null) {
		123	cachedValues.remove(new IdentityWrapper(domainElement));
91	listenerSupport.unhookListener(domainElement);	124	listenerSupport.unhookListener(domainElement);
92	}	125	}
93	}	126	}
Lines 113-121 Link Here
113	protected Object doPut(Object key, Object value) {	146	protected Object doPut(Object key, Object value) {
114	try {	147	try {
115	Object oldValue = get(key);	148	Object oldValue = get(key);
116	propertyDescriptor.getWriteMethod().invoke(key,	149	if (!Util.equals(oldValue, value)) {
117	new Object[] { value });	150	Method writeMethod = propertyDescriptor.getWriteMethod();
118	keySet().add(key);	151	if (!writeMethod.isAccessible()) {
		152	writeMethod.setAccessible(true);
		153	}
		154	writeMethod.invoke(key, new Object[] { value });
		155	}
		156
		157	if (hasListeners()) {
		158	// oldValue contains the live value which may be different from
		159	// the cached value if the bean does not have listener API or
		160	// does not fire events properly. For consistency we want to
		161	// provide the cached value as the old value, rather than the
		162	// live value so that consumers that hook/unhook listeners can
		163	// do so without maintaining caches of their own.
		164	Object newValue = doGet(key);
		165	oldValue = cachedValues.put(new IdentityWrapper(key), newValue);
		166
		167	if (!Util.equals(oldValue, newValue)) {
		168	fireSingleChange(key, oldValue, newValue);
		169	}
		170	}
119	return oldValue;	171	return oldValue;
120	} catch (Exception e) {	172	} catch (Exception e) {
121	Policy.getLog().log(	173	Policy.getLog().log(




 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 221704)
 *     Matthew Hall - bug 223164, 226289, 244098, 246103
 *******************************************************************************/

package org.eclipse.core.internal.databinding.beans;

					if (!updating) {
						getRealm().exec(new Runnable() {
							public void run() {
								Map oldMap = (Map) event.getOldValue();
								Map newMap = (Map) event.getNewValue();
								if (oldMap == null && newMap == null) {
									oldMap = wrappedMap;
									newMap = getMap();
								}

								if (!Util.equals(oldMap, newMap)) {
									wrappedMap = new HashMap(newMap);
									fireMapChange(Diffs.computeMapDiff(oldMap,
											newMap));
								}
							}
						});
					}

		checkRealm();
		updating = true;
		try {
			boolean add = !wrappedMap.containsKey(key);
			Object result = wrappedMap.put(key, value);
			if (!Util.equals(result, value)) {
				setMap();
				if (add) {
					fireMapChange(Diffs.createMapDiffSingleAdd(key, value));
				} else {
					fireMapChange(Diffs.createMapDiffSingleChange(key, result,

				Map.Entry entry = (Entry) it.next();
				Object key = entry.getKey();
				Object newValue = entry.getValue();
				boolean add = !wrappedMap.containsKey(key);
				Object oldValue = wrappedMap.put(key, newValue);
				if (add) {
					addedKeys.add(key);
				} else if (!Util.equals(oldValue, newValue)) {
					changes.put(key, oldValue);


	public Object remove(Object key) {
		checkRealm();
		if (!wrappedMap.containsKey(key)) {
			return null;
		}
		updating = true;
		try {
			Object result = wrappedMap.remove(key);
			setMap();
			fireMapChange(Diffs.createMapDiffSingleRemove(key, result));
				fireMapChange(Diffs.createMapDiffSingleRemove(key, result));
			}
			return result;
		} finally {
			updating = false;

Lines 9-14 Link Here

(-)src/org/eclipse/core/internal/databinding/beans/JavaBeanObservableValue.java (-23 / +55 lines)
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Brad Reynolds - bug 164653	10	* Brad Reynolds - bug 164653
11	* Brad Reynolds - bug 164134, 171616	11	* Brad Reynolds - bug 164134, 171616
		12	* Matthew Hall - bug 246103
12	*******************************************************************************/	13	*******************************************************************************/
13	package org.eclipse.core.internal.databinding.beans;	14	package org.eclipse.core.internal.databinding.beans;
14		15
Lines 23-29 Link Here
23	import org.eclipse.core.databinding.observable.Diffs;	24	import org.eclipse.core.databinding.observable.Diffs;
24	import org.eclipse.core.databinding.observable.Realm;	25	import org.eclipse.core.databinding.observable.Realm;
25	import org.eclipse.core.databinding.observable.value.AbstractObservableValue;	26	import org.eclipse.core.databinding.observable.value.AbstractObservableValue;
26	import org.eclipse.core.databinding.observable.value.ValueDiff;
27	import org.eclipse.core.databinding.util.Policy;	27	import org.eclipse.core.databinding.util.Policy;
28	import org.eclipse.core.internal.databinding.Util;	28	import org.eclipse.core.internal.databinding.Util;
29	import org.eclipse.core.runtime.IStatus;	29	import org.eclipse.core.runtime.IStatus;
Lines 42-47 Link Here
42		42
43	private boolean attachListeners;	43	private boolean attachListeners;
44		44
		45	// Applicable only while hasListeners() == true
		46	private Object cachedValue;
		47
45	/**	48	/**
46	* @param realm	49	* @param realm
47	* @param object	50	* @param object
Lines 70-94 Link Here
70	if (!attachListeners) {	73	if (!attachListeners) {
71	return;	74	return;
72	}	75	}
73		76
74	PropertyChangeListener listener = new PropertyChangeListener() {
75	public void propertyChange(java.beans.PropertyChangeEvent event) {
76	if (!updating) {
77	final ValueDiff diff = Diffs.createValueDiff(event.getOldValue(),
78	event.getNewValue());
79	getRealm().exec(new Runnable(){
80	public void run() {
81	fireValueChange(diff);
82	}});
83	}
84	}
85	};
86
87	if (listenerSupport == null) {	77	if (listenerSupport == null) {
88	listenerSupport = new ListenerSupport(listener, propertyDescriptor.getName());	78	PropertyChangeListener listener = new PropertyChangeListener() {
		79	public void propertyChange(
		80	final java.beans.PropertyChangeEvent event) {
		81	if (!updating) {
		82	getRealm().exec(new Runnable() {
		83	public void run() {
		84	Object oldValue = event.getOldValue();
		85	Object newValue = event.getNewValue();
		86	if (oldValue == null && newValue == null) {
		87	// this condition is provided for in the
		88	// bean spec,
		89	// and indicates that an unknown change
		90	// occured.
		91
		92	oldValue = cachedValue;
		93	newValue = doGetValue();
		94	}
		95	cachedValue = newValue;
		96	if (!Util.equals(oldValue, newValue)) {
		97	fireValueChange(Diffs.createValueDiff(
		98	oldValue, newValue));
		99	}
		100	}
		101	});
		102	}
		103	}
		104	};
		105	listenerSupport = new ListenerSupport(listener, propertyDescriptor
		106	.getName());
89	}	107	}
90		108
91	listenerSupport.hookListener(object);	109	listenerSupport.hookListener(object);
		110	cachedValue = doGetValue();
92	}	111	}
93		112
94	public void doSetValue(Object value) {	113	public void doSetValue(Object value) {
Lines 96-111 Link Here
96	try {	115	try {
97	Object oldValue = doGetValue();	116	Object oldValue = doGetValue();
98		117
99	if (Util.equals(oldValue, value)) {	118	if (!Util.equals(oldValue, value)) {
100	return;	119	Method writeMethod = propertyDescriptor.getWriteMethod();
		120	if (!writeMethod.isAccessible()) {
		121	writeMethod.setAccessible(true);
		122	}
		123	writeMethod.invoke(object, new Object[] { value });
101	}	124	}
102		125
103	Method writeMethod = propertyDescriptor.getWriteMethod();	126	if (hasListeners()) {
104	if (!writeMethod.isAccessible()) {	127	// oldValue contains the live value which may be different from
105	writeMethod.setAccessible(true);	128	// the cached value if the bean does not have listener API or
		129	// does not fire events properly. For consistency we want to
		130	// provide the cached value as the old value, rather than the
		131	// live value so that consumers that hook/unhook listeners can
		132	// do so without maintaining caches of their own.
		133	oldValue = cachedValue;
		134	cachedValue = doGetValue();
		135	if (!Util.equals(oldValue, cachedValue)) {
		136	fireValueChange(Diffs
		137	.createValueDiff(oldValue, cachedValue));
		138	}
106	}	139	}
107	writeMethod.invoke(object, new Object[] { value });
108	fireValueChange(Diffs.createValueDiff(oldValue, doGetValue()));
109	} catch (InvocationTargetException e) {	140	} catch (InvocationTargetException e) {
110	/*	141	/*
111	* InvocationTargetException wraps any exception thrown by the	142	* InvocationTargetException wraps any exception thrown by the
Lines 165-170 Link Here
165	}	196	}
166		197
167	private void unhookListener() {	198	private void unhookListener() {
		199	cachedValue = null;
168	if (listenerSupport != null) {	200	if (listenerSupport != null) {
169	listenerSupport.dispose();	201	listenerSupport.dispose();
170	listenerSupport = null;	202	listenerSupport = null;

Return to bug 246103

Lines 8-14 Link Here

(-)src/org/eclipse/core/databinding/observable/map/AbstractObservableMap.java (-10 / +29 lines)
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Brad Reynolds - bug 164653	10	* Brad Reynolds - bug 164653
11	* Matthew Hall - bugs 118516, 146397, 226289	11	* Matthew Hall - bugs 118516, 146397, 226289, 246103
12	*******************************************************************************/	12	*******************************************************************************/
13		13
14	package org.eclipse.core.databinding.observable.map;	14	package org.eclipse.core.databinding.observable.map;
Lines 38-44 Link Here
38	public abstract class AbstractObservableMap extends AbstractMap implements	38	public abstract class AbstractObservableMap extends AbstractMap implements
39	IObservableMap {	39	IObservableMap {
40		40
41	private ChangeSupport changeSupport;	41	private final class PrivateChangeSupport extends ChangeSupport {
		42	private PrivateChangeSupport(Realm realm) {
		43	super(realm);
		44	}
		45
		46	protected void firstListenerAdded() {
		47	AbstractObservableMap.this.firstListenerAdded();
		48	}
		49
		50	protected void lastListenerRemoved() {
		51	AbstractObservableMap.this.lastListenerRemoved();
		52	}
		53
		54	protected boolean hasListeners() {
		55	return super.hasListeners();
		56	}
		57	}
		58
		59	private PrivateChangeSupport changeSupport;
42	private boolean disposed = false;	60	private boolean disposed = false;
43		61
44	private boolean stale;	62	private boolean stale;
Lines 66-79 Link Here
66	*/	84	*/
67	public AbstractObservableMap(Realm realm) {	85	public AbstractObservableMap(Realm realm) {
68	Assert.isNotNull(realm, "Realm cannot be null"); //$NON-NLS-1$	86	Assert.isNotNull(realm, "Realm cannot be null"); //$NON-NLS-1$
69	changeSupport = new ChangeSupport(realm){	87	changeSupport = new PrivateChangeSupport(realm);
70	protected void firstListenerAdded() {
71	AbstractObservableMap.this.firstListenerAdded();
72	}
73	protected void lastListenerRemoved() {
74	AbstractObservableMap.this.lastListenerRemoved();
75	}
76	};
77	}	88	}
78		89
79	public synchronized void addMapChangeListener(IMapChangeListener listener) {	90	public synchronized void addMapChangeListener(IMapChangeListener listener) {
Lines 97-102 Link Here
97	}	108	}
98		109
99	/**	110	/**
		111	* @return whether the observable map has listeners registered
		112	* @since 1.2
		113	*/
		114	protected synchronized boolean hasListeners() {
		115	return !disposed && changeSupport.hasListeners();
		116	}
		117
		118	/**
100	* @since 1.2	119	* @since 1.2
101	*/	120	*/
102	public void addDisposeListener(IDisposeListener listener) {	121	public void addDisposeListener(IDisposeListener listener) {

Lines 7-26 Link Here

(-)src/org/eclipse/core/tests/internal/databinding/beans/JavaBeanObservableMapTest.java (-1 / +36 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Matthew Hall - bugs 213145, 241585	10	* Matthew Hall - bugs 213145, 241585, 246103
11	*******************************************************************************/	11	*******************************************************************************/
12		12
13	package org.eclipse.core.tests.internal.databinding.beans;	13	package org.eclipse.core.tests.internal.databinding.beans;
14		14
15	import java.beans.PropertyDescriptor;	15	import java.beans.PropertyDescriptor;
		16	import java.util.Collections;
16	import java.util.HashSet;	17	import java.util.HashSet;
17		18
18	import junit.framework.Test;	19	import junit.framework.Test;
19	import junit.framework.TestCase;	20	import junit.framework.TestCase;
20	import junit.framework.TestSuite;	21	import junit.framework.TestSuite;
21		22
		23	import org.eclipse.core.databinding.beans.BeansObservables;
22	import org.eclipse.core.databinding.observable.Realm;	24	import org.eclipse.core.databinding.observable.Realm;
23	import org.eclipse.core.databinding.observable.map.IMapChangeListener;	25	import org.eclipse.core.databinding.observable.map.IMapChangeListener;
		26	import org.eclipse.core.databinding.observable.map.IObservableMap;
24	import org.eclipse.core.databinding.observable.map.MapChangeEvent;	27	import org.eclipse.core.databinding.observable.map.MapChangeEvent;
25	import org.eclipse.core.databinding.observable.map.MapDiff;	28	import org.eclipse.core.databinding.observable.map.MapDiff;
26	import org.eclipse.core.databinding.observable.set.WritableSet;	29	import org.eclipse.core.databinding.observable.set.WritableSet;
Lines 28-33 Link Here
28	import org.eclipse.core.tests.databinding.observable.ThreadRealm;	31	import org.eclipse.core.tests.databinding.observable.ThreadRealm;
29	import org.eclipse.jface.databinding.conformance.util.ChangeEventTracker;	32	import org.eclipse.jface.databinding.conformance.util.ChangeEventTracker;
30	import org.eclipse.jface.databinding.conformance.util.CurrentRealm;	33	import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
		34	import org.eclipse.jface.databinding.conformance.util.MapChangeEventTracker;
31		35
32	/**	36	/**
33	* @since 3.2	37	* @since 3.2
Lines 166-171 Link Here
166	assertTrue(bean.hasListeners("value"));	170	assertTrue(bean.hasListeners("value"));
167	}	171	}
168		172
		173	public void testSetBeanProperty_CorrectForNullOldAndNewValues() {
		174	// The java bean spec allows the old and new values in a
		175	// PropertyChangeEvent to be null, which indicates that an unknown
		176	// change occured.
		177
		178	// This test ensures that JavaBeanObservableValue fires the correct
		179	// value diff even if the bean implementor is lazy :-P
		180
		181	WritableSet set = new WritableSet(new CurrentRealm(true));
		182
		183	Bean bean = new AnnoyingBean();
		184	bean.setValue("old");
		185	set.add(bean);
		186
		187	IObservableMap map = BeansObservables.observeMap(set, Bean.class,
		188	"value");
		189	MapChangeEventTracker tracker = MapChangeEventTracker.observe(map);
		190
		191	bean.setValue("new");
		192
		193	assertEquals(1, tracker.count);
		194
		195	assertEquals(Collections.EMPTY_SET, tracker.event.diff.getAddedKeys());
		196	assertEquals(Collections.singleton(bean), tracker.event.diff
		197	.getChangedKeys());
		198	assertEquals(Collections.EMPTY_SET, tracker.event.diff.getRemovedKeys());
		199
		200	assertEquals("old", tracker.event.diff.getOldValue(bean));
		201	assertEquals("new", tracker.event.diff.getNewValue(bean));
		202	}
		203
169	private static class MapChangeListener implements IMapChangeListener {	204	private static class MapChangeListener implements IMapChangeListener {
170	int count;	205	int count;
171		206

Lines 9-15 Link Here

(-)src/org/eclipse/core/tests/internal/databinding/beans/JavaBeanObservableValueTest.java (-1 / +19 lines)
9	* Brad Reynolds - initial API and implementation	9	* Brad Reynolds - initial API and implementation
10	* Brad Reynolds - bug 171616	10	* Brad Reynolds - bug 171616
11	* Katarzyna Marszalek - test case for bug 198519	11	* Katarzyna Marszalek - test case for bug 198519
12	* Matthew Hall - bug 213145	12	* Matthew Hall - bug 213145, 246103
13	******************************************************************************/	13	******************************************************************************/
14		14
15	package org.eclipse.core.tests.internal.databinding.beans;	15	package org.eclipse.core.tests.internal.databinding.beans;
Lines 31-36 Link Here
31	import org.eclipse.jface.databinding.conformance.MutableObservableValueContractTest;	31	import org.eclipse.jface.databinding.conformance.MutableObservableValueContractTest;
32	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;	32	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
33	import org.eclipse.jface.databinding.conformance.util.ChangeEventTracker;	33	import org.eclipse.jface.databinding.conformance.util.ChangeEventTracker;
		34	import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;
34	import org.eclipse.jface.examples.databinding.model.SimplePerson;	35	import org.eclipse.jface.examples.databinding.model.SimplePerson;
35	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;	36	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
36		37
Lines 121-126 Link Here
121	assertFalse(bean.hasListeners(propertyName));	122	assertFalse(bean.hasListeners(propertyName));
122	}	123	}
123		124
		125	public void testSetBeanProperty_CorrectForNullOldAndNewValues() {
		126	// The java bean spec allows the old and new values in a PropertyChangeEvent to
		127	// be null, which indicates that an unknown change occured.
		128
		129	// This test ensures that JavaBeanObservableValue fires the correct value diff
		130	// even if the bean implementor is lazy :-P
		131
		132	Bean bean = new AnnoyingBean();
		133	bean.setValue("old");
		134	IObservableValue observable = BeansObservables.observeValue(bean, "value");
		135	ValueChangeEventTracker tracker = ValueChangeEventTracker.observe(observable);
		136	bean.setValue("new");
		137	assertEquals(1, tracker.count);
		138	assertEquals("old", tracker.event.diff.getOldValue());
		139	assertEquals("new", tracker.event.diff.getNewValue());
		140	}
		141
124	public static Test suite() {	142	public static Test suite() {
125	TestSuite suite = new TestSuite(JavaBeanObservableValueTest.class.getName());	143	TestSuite suite = new TestSuite(JavaBeanObservableValueTest.class.getName());
126	suite.addTestSuite(JavaBeanObservableValueTest.class);	144	suite.addTestSuite(JavaBeanObservableValueTest.class);

Lines 13-19 Link Here

(-)src/org/eclipse/jface/tests/databinding/BindingTestSuite.java (-1 / +3 lines)
13	* Ashley Cambrell - bugs 198903, 198904	13	* Ashley Cambrell - bugs 198903, 198904
14	* Matthew Hall - bugs 210115, 212468, 212223, 206839, 208858, 208322,	14	* Matthew Hall - bugs 210115, 212468, 212223, 206839, 208858, 208322,
15	* 212518, 215531, 221351, 184830, 213145, 218269, 239015,	15	* 212518, 215531, 221351, 184830, 213145, 218269, 239015,
16	* 237703, 237718, 222289, 247394, 233306, 247647	16	* 237703, 237718, 222289, 247394, 233306, 247647, 246103
17	* Ovidio Mallo - bug 237163, bug 235195	17	* Ovidio Mallo - bug 237163, bug 235195
18	*******************************************************************************/	18	*******************************************************************************/
19	package org.eclipse.jface.tests.databinding;	19	package org.eclipse.jface.tests.databinding;
Lines 80-85 Link Here
80	import org.eclipse.core.tests.internal.databinding.beans.JavaBeanObservableMapTest;	80	import org.eclipse.core.tests.internal.databinding.beans.JavaBeanObservableMapTest;
81	import org.eclipse.core.tests.internal.databinding.beans.JavaBeanObservableSetTest;	81	import org.eclipse.core.tests.internal.databinding.beans.JavaBeanObservableSetTest;
82	import org.eclipse.core.tests.internal.databinding.beans.JavaBeanObservableValueTest;	82	import org.eclipse.core.tests.internal.databinding.beans.JavaBeanObservableValueTest;
		83	import org.eclipse.core.tests.internal.databinding.beans.JavaBeanPropertyObservableMapTest;
83	import org.eclipse.core.tests.internal.databinding.beans.ListenerSupportTest;	84	import org.eclipse.core.tests.internal.databinding.beans.ListenerSupportTest;
84	import org.eclipse.core.tests.internal.databinding.conversion.DateConversionSupportTest;	85	import org.eclipse.core.tests.internal.databinding.conversion.DateConversionSupportTest;
85	import org.eclipse.core.tests.internal.databinding.conversion.IdentityConverterTest;	86	import org.eclipse.core.tests.internal.databinding.conversion.IdentityConverterTest;
Lines 303-308 Link Here
303	addTest(JavaBeanObservableMapTest.suite());	304	addTest(JavaBeanObservableMapTest.suite());
304	addTest(JavaBeanObservableSetTest.suite());	305	addTest(JavaBeanObservableSetTest.suite());
305	addTest(JavaBeanObservableValueTest.suite());	306	addTest(JavaBeanObservableValueTest.suite());
		307	addTestSuite(JavaBeanPropertyObservableMapTest.class);
306	addTestSuite(ListenerSupportTest.class);	308	addTestSuite(ListenerSupportTest.class);
307		309
308	//org.eclipse.core.tests.internal.databinding.observable	310	//org.eclipse.core.tests.internal.databinding.observable

Added Link Here

(-)src/org/eclipse/core/tests/internal/databinding/beans/AnnoyingBean.java (+106 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 Matthew Hall 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	* Matthew Hall - initial API and implementation (bug 246103)
10	******************************************************************************/
11
12	package org.eclipse.core.tests.internal.databinding.beans;
13
14	import java.util.List;
15	import java.util.Map;
16	import java.util.Set;
17
18	/**
19	* A bean in which all property change events are fired according to an annoying
20	* provision in the bean spec, where <code>(oldValue == null && newValue ==
21	* null)</code> indicates that an unknown change occured.
22	*
23	* @since 3.2
24	*/
25	public class AnnoyingBean extends Bean {
26	public void setValue(String value) {
27	this.value = value;
28	changeSupport.firePropertyChange("value", null, null);
29	}
30
31	public void setArray(Object[] array) {
32	this.array = array;
33	changeSupport.firePropertyChange("array", null, null);
34	}
35
36	public void setList(List list) {
37	this.list = list;
38	changeSupport.firePropertyChange("list", null, null);
39	}
40
41	public void setSet(Set set) {
42	this.set = set;
43	changeSupport.firePropertyChange("set", null, null);
44	}
45
46	public void setMap(Map map) {
47	this.map = map;
48	changeSupport.firePropertyChange("map", null, null);
49	}
50	}
Added Link Here
1	/*******************************************************************************
2	* Copyright (c) 2008 Matthew Hall 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	* Matthew Hall - initial API and implementation (bug 246103)
10	******************************************************************************/
11
12	package org.eclipse.core.tests.internal.databinding.beans;
13
14	import java.util.Collections;
15
16	import org.eclipse.core.databinding.beans.BeansObservables;
17	import org.eclipse.core.databinding.observable.map.IObservableMap;
18	import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
19	import org.eclipse.jface.databinding.conformance.util.MapChangeEventTracker;
20	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
21
22	/**
23	* @since 3.2
24	*
25	*/
26	public class JavaBeanPropertyObservableMapTest extends
27	AbstractDefaultRealmTestCase {
28	public void testSetBeanProperty_CorrectForNullOldAndNewValues() {
29	// The java bean spec allows the old and new values in a
30	// PropertyChangeEvent to be null, which indicates that an unknown
31	// change occured.
32
33	// This test ensures that JavaBeanObservableValue fires the correct
34	// value diff even if the bean implementor is lazy :-P
35
36	Bean bean = new AnnoyingBean();
37	bean.setMap(Collections.singletonMap("key", "old"));
38
39	IObservableMap map = BeansObservables.observeMap(
40	new CurrentRealm(true), bean, "map");
41	MapChangeEventTracker tracker = MapChangeEventTracker.observe(map);
42
43	bean.setMap(Collections.singletonMap("key", "new"));
44
45	assertEquals(1, tracker.count);
46
47	assertEquals(Collections.EMPTY_SET, tracker.event.diff.getAddedKeys());
48	assertEquals(Collections.singleton("key"), tracker.event.diff
49	.getChangedKeys());
50	assertEquals(Collections.EMPTY_SET, tracker.event.diff.getRemovedKeys());
51
52	assertEquals("old", tracker.event.diff.getOldValue("key"));
53	assertEquals("new", tracker.event.diff.getNewValue("key"));
54	}
55
56	}