Attachment #113686 for bug #248868




 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 218269)
 *     Ovidio Mallo - bug 248868
 ******************************************************************************/

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


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

import org.eclipse.jface.databinding.conformance.MutableObservableValueContractTest;
import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
import org.eclipse.jface.databinding.conformance.util.StaleEventTracker;
import org.eclipse.jface.databinding.conformance.util.ValueChangeEventTracker;
import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;


public class ValidatedObservableValueTest extends AbstractDefaultRealmTestCase {
	private ValidatedObservableValue validated;
	private ObservableValueStub target;
	private ValidationObservableValue validationStatus;

	private Object oldValue;
	private Object newValue;

		newValue = new Object();
		target = new ObservableValueStub(Realm.getDefault());
		target.setValue(oldValue);
		validationStatus = new ValidationObservableValue();
				IStatus.class);
		validated = new ValidatedObservableValue(target, validationStatus);
	}


		CurrentRealm realm1 = new CurrentRealm(true);
		CurrentRealm realm2 = new CurrentRealm(true);
		target = new ObservableValueStub(realm1);
		validationStatus = new ValidationObservableValue(realm2);
		try {
			new ValidatedObservableValue(target, validationStatus);
			fail("Expected exception--target and validation status should have the same realm");

	}

	public void testIsStale_WhenTargetIsStale() {
		ValueChangeEventTracker validatedValueTracker = ValueChangeEventTracker
				.observe(validated);
		StaleEventTracker validatedStaleTracker = StaleEventTracker
				.observe(validated);

		assertFalse(target.isStale());
		assertFalse(validated.isStale());
		assertEquals(0, validatedValueTracker.count);
		assertEquals(0, validatedStaleTracker.count);

		target.fireStale();

		assertTrue(target.isStale());
		assertTrue(validated.isStale());
		assertEquals(0, validatedValueTracker.count);
		assertEquals(1, validatedStaleTracker.count); // +1

		// Set the same value on the target again. Since we are stale, this
		// should trigger a value change event to become unstale.
		target.setValue(target.getValue());

		assertFalse(target.isStale());
		assertFalse(validated.isStale());
		assertEquals(1, validatedValueTracker.count); // +1
		assertEquals(1, validatedStaleTracker.count);
	}

	public void testIsStale_WhileChangesPending() {
		ValueChangeEventTracker validatedValueTracker = ValueChangeEventTracker
				.observe(validated);
		StaleEventTracker validatedStaleTracker = StaleEventTracker
				.observe(validated);

		assertFalse(target.isStale());
		assertFalse(validated.isStale());


		// value but the validation status is not OK.
		assertFalse(target.isStale());
		assertFalse(validated.isStale());
		assertEquals(0, validatedValueTracker.count);
		assertEquals(0, validatedStaleTracker.count);

		target.setValue(newValue);

		assertFalse(target.isStale());
		assertTrue(validated.isStale());
		assertEquals(0, validatedValueTracker.count);
		assertEquals(1, validatedStaleTracker.count); // +1

		validationStatus.setValue(ValidationStatus.ok());

		assertFalse(validated.isStale());
		assertEquals(1, validatedValueTracker.count); // +1
		assertEquals(1, validatedStaleTracker.count);
	}

	public void testIsStale_WhenStatusIsStale() {
		ValueChangeEventTracker validatedValueTracker = ValueChangeEventTracker
				.observe(validated);
		StaleEventTracker validatedStaleTracker = StaleEventTracker
				.observe(validated);

		assertFalse(validationStatus.isStale());
		assertFalse(validated.isStale());
		assertEquals(0, validatedValueTracker.count);
		assertEquals(0, validatedStaleTracker.count);

		// Become stale and check that we receive a stale event.
		validationStatus.setStale(true);

		assertTrue(validationStatus.isStale());
		assertTrue(validated.isStale());
		assertEquals(0, validatedValueTracker.count);
		assertEquals(1, validatedStaleTracker.count); // +1

		// Become unstale again and check that we receive a change event.
		validationStatus.setStale(false);

		assertFalse(validationStatus.isStale());
		assertFalse(validated.isStale());
		assertEquals(1, validatedValueTracker.count); // +1
		assertEquals(1, validatedStaleTracker.count);
	}

	public void testEvents_WhenStatusIsStale() {
		ValueChangeEventTracker validatedValueTracker = ValueChangeEventTracker
				.observe(validated);
		StaleEventTracker validatedStaleTracker = StaleEventTracker
				.observe(validated);

		assertFalse(validationStatus.isStale());
		assertFalse(validated.isStale());
		assertEquals(0, validatedValueTracker.count);
		assertEquals(0, validatedStaleTracker.count);

		// Become stale and check that we receive a stale event.
		validationStatus.setStale(true);

		assertTrue(validationStatus.isStale());
		assertTrue(validated.isStale());
		assertEquals(0, validatedValueTracker.count);
		assertEquals(1, validatedStaleTracker.count); // +1

		// Changes to the target observable should not be propagated while the
		// validation is stale.
		target.setValue(new Object());

		assertEquals(0, validatedValueTracker.count);
		assertEquals(1, validatedStaleTracker.count);

		// Changes to the validated observable should be propagated while the
		// validation is stale but we remain stale.
		validated.setValue(new Object());

		assertTrue(validated.isStale());
		assertEquals(1, validatedValueTracker.count); // +1
		assertEquals(1, validatedStaleTracker.count);

		// Finally, become unstale and check that we receive a change event.
		validationStatus.setStale(false);

		assertFalse(validationStatus.isStale());
		assertFalse(validated.isStale());
		assertEquals(2, validatedValueTracker.count); // +1
		assertEquals(1, validatedStaleTracker.count);
	}

	public void testGetValueType_SameAsTarget() {

		assertTrue(target.isStale());
		assertTrue(validated.isStale());

		// Set a new value on the target.
		target.setValue(newValue);

		assertTrue(target.isStale());
		assertTrue(validated.isStale());

		// Set a new value on the validated observable.
		validated.setValue(new Object());

		assertTrue(target.isStale());
		assertTrue(validated.isStale());
	}

	static class ObservableValueStub extends AbstractObservableValue {

		}
	}

	private static class ValidationObservableValue extends WritableValue {
		private boolean stale = false;

		public ValidationObservableValue() {
			this(Realm.getDefault());
		}

		public ValidationObservableValue(Realm realm) {
			super(realm, ValidationStatus.ok(), IStatus.class);
		}

		public boolean isStale() {
			ObservableTracker.getterCalled(this);
			return stale;
		}

		public void setStale(boolean stale) {
			if (this.stale != stale) {
				this.stale = stale;
				if (stale) {
					fireStale();
				} else {
					fireValueChange(Diffs.createValueDiff(doGetValue(),
							doGetValue()));
				}
			}
		}
	}
}

Lines 7-12 Link Here

(-)src/org/eclipse/core/tests/internal/databinding/observable/ValidatedObservableSetTest.java (-1 / +119 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* Matthew Hall - initial API and implementation (bug 218269)	9	* Matthew Hall - initial API and implementation (bug 218269)
		10	* Ovidio Mallo - bug 248868
10	******************************************************************************/	11	******************************************************************************/
11		12
12	package org.eclipse.core.tests.internal.databinding.observable;	13	package org.eclipse.core.tests.internal.databinding.observable;
Lines 14-22 Link Here
14	import java.util.Collections;	15	import java.util.Collections;
15		16
16	import junit.framework.Test;	17	import junit.framework.Test;
		18	import junit.framework.TestSuite;
17		19
		20	import org.eclipse.core.databinding.observable.Diffs;
18	import org.eclipse.core.databinding.observable.IObservable;	21	import org.eclipse.core.databinding.observable.IObservable;
19	import org.eclipse.core.databinding.observable.IObservableCollection;	22	import org.eclipse.core.databinding.observable.IObservableCollection;
		23	import org.eclipse.core.databinding.observable.ObservableTracker;
20	import org.eclipse.core.databinding.observable.Realm;	24	import org.eclipse.core.databinding.observable.Realm;
21	import org.eclipse.core.databinding.observable.set.IObservableSet;	25	import org.eclipse.core.databinding.observable.set.IObservableSet;
22	import org.eclipse.core.databinding.observable.set.WritableSet;	26	import org.eclipse.core.databinding.observable.set.WritableSet;
Lines 27-37 Link Here
27	import org.eclipse.core.runtime.IStatus;	31	import org.eclipse.core.runtime.IStatus;
28	import org.eclipse.jface.databinding.conformance.MutableObservableSetContractTest;	32	import org.eclipse.jface.databinding.conformance.MutableObservableSetContractTest;
29	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableCollectionContractDelegate;	33	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableCollectionContractDelegate;
		34	import org.eclipse.jface.databinding.conformance.util.SetChangeEventTracker;
		35	import org.eclipse.jface.databinding.conformance.util.StaleEventTracker;
30	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;	36	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
31		37
32	public class ValidatedObservableSetTest extends AbstractDefaultRealmTestCase {	38	public class ValidatedObservableSetTest extends AbstractDefaultRealmTestCase {
		39	private ValidatedObservableSet validated;
		40	private IObservableSet target;
		41	private ValidationObservableValue validationStatus;
		42
		43	protected void setUp() throws Exception {
		44	super.setUp();
		45
		46	target = new WritableSet();
		47	validationStatus = new ValidationObservableValue();
		48	validated = new ValidatedObservableSet(target, validationStatus);
		49	}
		50
		51	public void testIsStale_WhenStatusIsStale() {
		52	SetChangeEventTracker validatedChangeTracker = SetChangeEventTracker
		53	.observe(validated);
		54	StaleEventTracker validatedStaleTracker = StaleEventTracker
		55	.observe(validated);
		56
		57	assertFalse(validationStatus.isStale());
		58	assertFalse(validated.isStale());
		59	assertEquals(0, validatedChangeTracker.count);
		60	assertEquals(0, validatedStaleTracker.count);
		61
		62	// Become stale and check that we receive a stale event.
		63	validationStatus.setStale(true);
		64
		65	assertTrue(validationStatus.isStale());
		66	assertTrue(validated.isStale());
		67	assertEquals(0, validatedChangeTracker.count);
		68	assertEquals(1, validatedStaleTracker.count); // +1
		69
		70	// Become unstale again and check that we receive a change event.
		71	validationStatus.setStale(false);
		72
		73	assertFalse(validationStatus.isStale());
		74	assertFalse(validated.isStale());
		75	assertEquals(1, validatedChangeTracker.count); // +1
		76	assertEquals(1, validatedStaleTracker.count);
		77	}
		78
		79	public void testEvents_WhenStatusIsStale() {
		80	SetChangeEventTracker validatedChangeTracker = SetChangeEventTracker
		81	.observe(validated);
		82	StaleEventTracker validatedStaleTracker = StaleEventTracker
		83	.observe(validated);
		84
		85	assertFalse(validationStatus.isStale());
		86	assertFalse(validated.isStale());
		87	assertEquals(0, validatedChangeTracker.count);
		88	assertEquals(0, validatedStaleTracker.count);
		89
		90	// Become stale and check that we receive a stale event.
		91	validationStatus.setStale(true);
		92
		93	assertTrue(validationStatus.isStale());
		94	assertTrue(validated.isStale());
		95	assertEquals(0, validatedChangeTracker.count);
		96	assertEquals(1, validatedStaleTracker.count); // +1
		97
		98	// Changes to the target observable should not be propagated while the
		99	// validation is stale.
		100	target.add(new Object());
		101
		102	assertEquals(0, validatedChangeTracker.count);
103	assertEquals(1, validatedStaleTracker.count);
104
105	// Changes to the validated observable should be propagated while the
106	// validation is stale but we remain stale.
107	validated.add(new Object());
108
109	assertTrue(validated.isStale());
110	assertEquals(1, validatedChangeTracker.count); // +1
111	assertEquals(1, validatedStaleTracker.count);
112
113	// Finally, become unstale and check that we receive a change event.
114	validationStatus.setStale(false);
115
116	assertFalse(validationStatus.isStale());
117	assertFalse(validated.isStale());
118	assertEquals(2, validatedChangeTracker.count); // +1
119	assertEquals(1, validatedStaleTracker.count);
120	}
121
33	public static Test suite() {	122	public static Test suite() {
34	return MutableObservableSetContractTest.suite(new Delegate());	123	TestSuite suite = new TestSuite(ValidatedObservableSetTest.class
		124	.getName());
		125	suite.addTestSuite(ValidatedObservableSetTest.class);
		126	suite.addTest(MutableObservableSetContractTest.suite(new Delegate()));
		127	return suite;
35	}	128	}
36		129
37	static class Delegate extends AbstractObservableCollectionContractDelegate {	130	static class Delegate extends AbstractObservableCollectionContractDelegate {
Lines 85-88 Link Here
85	this.validationStatus = validationStatus;	178	this.validationStatus = validationStatus;
86	}	179	}
87	}	180	}
		181
		182	private static class ValidationObservableValue extends WritableValue {
		183	private boolean stale = false;
		184
		185	public ValidationObservableValue() {
		186	super(ValidationStatus.ok(), IStatus.class);
		187	}
		188
		189	public boolean isStale() {
		190	ObservableTracker.getterCalled(this);
		191	return stale;
		192	}
		193
		194	public void setStale(boolean stale) {
		195	if (this.stale != stale) {
		196	this.stale = stale;
		197	if (stale) {
		198	fireStale();
		199	} else {
		200	fireValueChange(Diffs.createValueDiff(doGetValue(),
		201	doGetValue()));
		202	}
		203	}
		204	}
		205	}
88	}	206	}

Lines 7-12 Link Here

(-)src/org/eclipse/core/tests/internal/databinding/observable/ValidatedObservableListTest.java (-1 / +118 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* Matthew Hall - initial API and implementation (bug 218269)	9	* Matthew Hall - initial API and implementation (bug 218269)
		10	* Ovidio Mallo - bug 248868
10	******************************************************************************/	11	******************************************************************************/
11		12
12	package org.eclipse.core.tests.internal.databinding.observable;	13	package org.eclipse.core.tests.internal.databinding.observable;
Lines 14-22 Link Here
14	import java.util.ArrayList;	15	import java.util.ArrayList;
15		16
16	import junit.framework.Test;	17	import junit.framework.Test;
		18	import junit.framework.TestSuite;
17		19
		20	import org.eclipse.core.databinding.observable.Diffs;
18	import org.eclipse.core.databinding.observable.IObservable;	21	import org.eclipse.core.databinding.observable.IObservable;
19	import org.eclipse.core.databinding.observable.IObservableCollection;	22	import org.eclipse.core.databinding.observable.IObservableCollection;
		23	import org.eclipse.core.databinding.observable.ObservableTracker;
20	import org.eclipse.core.databinding.observable.Realm;	24	import org.eclipse.core.databinding.observable.Realm;
21	import org.eclipse.core.databinding.observable.list.IObservableList;	25	import org.eclipse.core.databinding.observable.list.IObservableList;
22	import org.eclipse.core.databinding.observable.list.WritableList;	26	import org.eclipse.core.databinding.observable.list.WritableList;
Lines 27-37 Link Here
27	import org.eclipse.core.runtime.IStatus;	31	import org.eclipse.core.runtime.IStatus;
28	import org.eclipse.jface.databinding.conformance.MutableObservableListContractTest;	32	import org.eclipse.jface.databinding.conformance.MutableObservableListContractTest;
29	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableCollectionContractDelegate;	33	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableCollectionContractDelegate;
		34	import org.eclipse.jface.databinding.conformance.util.ListChangeEventTracker;
		35	import org.eclipse.jface.databinding.conformance.util.StaleEventTracker;
30	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;	36	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
31		37
32	public class ValidatedObservableListTest extends AbstractDefaultRealmTestCase {	38	public class ValidatedObservableListTest extends AbstractDefaultRealmTestCase {
		39	private ValidatedObservableList validated;
		40	private IObservableList target;
		41	private ValidationObservableValue validationStatus;
		42
		43	protected void setUp() throws Exception {
		44	super.setUp();
		45
		46	target = new WritableList();
		47	validationStatus = new ValidationObservableValue();
		48	validated = new ValidatedObservableList(target, validationStatus);
		49	}
		50
		51	public void testIsStale_WhenStatusIsStale() {
		52	ListChangeEventTracker validatedChangeTracker = ListChangeEventTracker
		53	.observe(validated);
		54	StaleEventTracker validatedStaleTracker = StaleEventTracker
		55	.observe(validated);
		56
		57	assertFalse(validationStatus.isStale());
		58	assertFalse(validated.isStale());
		59	assertEquals(0, validatedChangeTracker.count);
		60	assertEquals(0, validatedStaleTracker.count);
		61
		62	// Become stale and check that we receive a stale event.
		63	validationStatus.setStale(true);
		64
		65	assertTrue(validationStatus.isStale());
		66	assertTrue(validated.isStale());
		67	assertEquals(0, validatedChangeTracker.count);
		68	assertEquals(1, validatedStaleTracker.count); // +1
		69
		70	// Become unstale again and check that we receive a change event.
		71	validationStatus.setStale(false);
		72
		73	assertFalse(validationStatus.isStale());
		74	assertFalse(validated.isStale());
		75	assertEquals(1, validatedChangeTracker.count); // +1
		76	assertEquals(1, validatedStaleTracker.count);
		77	}
		78
		79	public void testEvents_WhenStatusIsStale() {
		80	ListChangeEventTracker validatedChangeTracker = ListChangeEventTracker
		81	.observe(validated);
		82	StaleEventTracker validatedStaleTracker = StaleEventTracker
		83	.observe(validated);
		84
		85	assertFalse(validationStatus.isStale());
		86	assertFalse(validated.isStale());
		87	assertEquals(0, validatedChangeTracker.count);
		88	assertEquals(0, validatedStaleTracker.count);
		89
		90	// Become stale and check that we receive a stale event.
		91	validationStatus.setStale(true);
		92
		93	assertTrue(validationStatus.isStale());
		94	assertTrue(validated.isStale());
		95	assertEquals(0, validatedChangeTracker.count);
		96	assertEquals(1, validatedStaleTracker.count); // +1
		97
		98	// Changes to the target observable should not be propagated while the
		99	// validation is stale.
		100	target.add(new Object());
		101
		102	assertEquals(0, validatedChangeTracker.count);
103	assertEquals(1, validatedStaleTracker.count);
104
105	// Changes to the validated observable should be propagated while the
106	// validation is stale but we remain stale.
107	validated.add(new Object());
108
109	assertTrue(validated.isStale());
110	assertEquals(1, validatedChangeTracker.count); // +1
111	assertEquals(1, validatedStaleTracker.count);
112
113	// Finally, become unstale and check that we receive a change event.
114	validationStatus.setStale(false);
115
116	assertFalse(validationStatus.isStale());
117	assertFalse(validated.isStale());
118	assertEquals(2, validatedChangeTracker.count); // +1
119	assertEquals(1, validatedStaleTracker.count);
120	}
121
33	public static Test suite() {	122	public static Test suite() {
34	return MutableObservableListContractTest.suite(new Delegate());	123	TestSuite suite = new TestSuite(ValidatedObservableListTest.class.getName());
		124	suite.addTestSuite(ValidatedObservableListTest.class);
		125	suite.addTest(MutableObservableListContractTest.suite(new Delegate()));
		126	return suite;
35	}	127	}
36		128
37	static class Delegate extends AbstractObservableCollectionContractDelegate {	129	static class Delegate extends AbstractObservableCollectionContractDelegate {
Lines 85-88 Link Here
85	this.validationStatus = validationStatus;	177	this.validationStatus = validationStatus;
86	}	178	}
87	}	179	}
		180
		181	private static class ValidationObservableValue extends WritableValue {
		182	private boolean stale = false;
		183
		184	public ValidationObservableValue() {
		185	super(ValidationStatus.ok(), IStatus.class);
		186	}
		187
		188	public boolean isStale() {
		189	ObservableTracker.getterCalled(this);
		190	return stale;
		191	}
		192
		193	public void setStale(boolean stale) {
		194	if (this.stale != stale) {
		195	this.stale = stale;
		196	if (stale) {
		197	fireStale();
		198	} else {
		199	fireValueChange(Diffs.createValueDiff(doGetValue(),
		200	doGetValue()));
		201	}
		202	}
		203	}
		204	}
88	}	205	}




/*******************************************************************************
 * Copyright (c) 2008 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 248868)
 ******************************************************************************/

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

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

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.ObservableTracker;
import org.eclipse.core.databinding.observable.map.IObservableMap;
import org.eclipse.core.databinding.observable.map.WritableMap;
import org.eclipse.core.databinding.observable.value.WritableValue;
import org.eclipse.core.databinding.validation.ValidationStatus;
import org.eclipse.core.internal.databinding.observable.ValidatedObservableMap;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.databinding.conformance.util.MapChangeEventTracker;
import org.eclipse.jface.databinding.conformance.util.StaleEventTracker;
import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;

public class ValidatedObservableMapTest extends AbstractDefaultRealmTestCase {
	private ValidatedObservableMap validated;
	private IObservableMap target;
	private ValidationObservableValue validationStatus;

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

		target = new WritableMap();
		validationStatus = new ValidationObservableValue();
		validated = new ValidatedObservableMap(target, validationStatus);
	}

	public void testIsStale_WhenStatusIsStale() {
		MapChangeEventTracker validatedChangeTracker = MapChangeEventTracker
				.observe(validated);
		StaleEventTracker validatedStaleTracker = StaleEventTracker
				.observe(validated);

		assertFalse(validationStatus.isStale());
		assertFalse(validated.isStale());
		assertEquals(0, validatedChangeTracker.count);
		assertEquals(0, validatedStaleTracker.count);

		// Become stale and check that we receive a stale event.
		validationStatus.setStale(true);

		assertTrue(validationStatus.isStale());
		assertTrue(validated.isStale());
		assertEquals(0, validatedChangeTracker.count);
		assertEquals(1, validatedStaleTracker.count); // +1

		// Become unstale again and check that we receive a change event.
		validationStatus.setStale(false);

		assertFalse(validationStatus.isStale());
		assertFalse(validated.isStale());
		assertEquals(1, validatedChangeTracker.count); // +1
		assertEquals(1, validatedStaleTracker.count);
	}

	public void testEvents_WhenStatusIsStale() {
		MapChangeEventTracker validatedChangeTracker = MapChangeEventTracker
				.observe(validated);
		StaleEventTracker validatedStaleTracker = StaleEventTracker
				.observe(validated);

		assertFalse(validationStatus.isStale());
		assertFalse(validated.isStale());
		assertEquals(0, validatedChangeTracker.count);
		assertEquals(0, validatedStaleTracker.count);

		// Become stale and check that we receive a stale event.
		validationStatus.setStale(true);

		assertTrue(validationStatus.isStale());
		assertTrue(validated.isStale());
		assertEquals(0, validatedChangeTracker.count);
		assertEquals(1, validatedStaleTracker.count); // +1

		// Changes to the target observable should not be propagated while the
		// validation is stale.
		target.put(new Object(), new Object());

		assertEquals(0, validatedChangeTracker.count);
		assertEquals(1, validatedStaleTracker.count);

		// Changes to the validated observable should be propagated while the
		// validation is stale but we remain stale.
		validated.put(new Object(), new Object());

		assertTrue(validated.isStale());
		assertEquals(1, validatedChangeTracker.count); // +1
		assertEquals(1, validatedStaleTracker.count);

		// Finally, become unstale and check that we receive a change event.
		validationStatus.setStale(false);

		assertFalse(validationStatus.isStale());
		assertFalse(validated.isStale());
		assertEquals(2, validatedChangeTracker.count); // +1
		assertEquals(1, validatedStaleTracker.count);
	}

	public static Test suite() {
		TestSuite suite = new TestSuite(ValidatedObservableMapTest.class
				.getName());
		suite.addTestSuite(ValidatedObservableMapTest.class);
		return suite;
	}

	private static class ValidationObservableValue extends WritableValue {
		private boolean stale = false;

		public ValidationObservableValue() {
			super(ValidationStatus.ok(), IStatus.class);
		}

		public boolean isStale() {
			ObservableTracker.getterCalled(this);
			return stale;
		}

		public void setStale(boolean stale) {
			if (this.stale != stale) {
				this.stale = stale;
				if (stale) {
					fireStale();
				} else {
					fireValueChange(Diffs.createValueDiff(doGetValue(),
							doGetValue()));
				}
			}
		}
	}
}




 *     Matthew Hall - initial API and implementation (bug 218269)
 *     Boris Bokowski - bug 218269
 *     Matthew Hall - bug 237884, 240590
 *     Ovidio Mallo - bugs 238909, 248868
 ******************************************************************************/

package org.eclipse.core.databinding.validation;


	/**
	 * Returns a wrapper {@link IObservableValue} which stays in sync with the
	 * given target observable only when the validation status is valid and not
	 * stale. Statuses of {@link IStatus#OK OK}, {@link IStatus#INFO INFO} or
	 * {@link IStatus#WARNING WARNING} severity are considered valid.
	 * <p>
	 * The wrapper behaves as follows with respect to the validation status:
	 * <ul>
	 * <li>While valid and not stale, the wrapper stays in sync with its target
	 * observable.
	 * <li>While invalid or stale, the wrapper's value is the target
	 * observable's last valid value. If the target changes value, a stale event
	 * is fired signaling that a change is pending.
	 * <li>When status changes from invalid to valid, the wrapper takes the
	 * value of the target observable, and synchronization resumes.
	 * </ul>


	/**
	 * Returns a wrapper {@link IObservableList} which stays in sync with the
	 * given target observable only when the validation status is valid and not
	 * stale. Statuses of {@link IStatus#OK OK}, {@link IStatus#INFO INFO} or
	 * {@link IStatus#WARNING WARNING} severity are considered valid.
	 * <p>
	 * The wrapper behaves as follows with respect to the validation status:
	 * <ul>
	 * <li>While valid and not stale, the wrapper stays in sync with its target
	 * observable.
	 * <li>While invalid or stale, the wrapper's elements are the target
	 * observable's last valid elements. If the target changes elements, a stale
	 * event is fired signaling that a change is pending.
	 * <li>When status changes from invalid to valid, the wrapper takes the
	 * elements of the target observable, and synchronization resumes.
	 * </ul>


	/**
	 * Returns a wrapper {@link IObservableSet} which stays in sync with the
	 * given target observable only when the validation status is valid and not
	 * stale. Statuses of {@link IStatus#OK OK}, {@link IStatus#INFO INFO} or
	 * {@link IStatus#WARNING WARNING} severity are considered valid.
	 * <p>
	 * The wrapper behaves as follows with respect to the validation status:
	 * <ul>
	 * <li>While valid and not stale, the wrapper stays in sync with its target
	 * observable.
	 * <li>While invalid or stale, the wrapper's elements are the target
	 * observable's last valid elements. If the target changes elements, a stale
	 * event is fired signaling that a change is pending.
	 * <li>When status changes from invalid to valid, the wrapper takes the
	 * elements of the target observable, and synchronization resumes.
	 * </ul>


	/**
	 * Returns a wrapper {@link IObservableMap} which stays in sync with the
	 * given target observable only when the validation status is valid and not
	 * stale. Statuses of {@link IStatus#OK OK}, {@link IStatus#INFO INFO} or
	 * {@link IStatus#WARNING WARNING} severity are considered valid.
	 * <p>
	 * The wrapper behaves as follows with respect to the validation status:
	 * <ul>
	 * <li>While valid and not stale, the wrapper stays in sync with its target
	 * observable.
	 * <li>While invalid or stale, the wrapper's entries are the target
	 * observable's last valid entries. If the target changes entries, a stale
	 * event is fired signaling that a change is pending.
	 * <li>When status changes from invalid to valid, the wrapper takes the
	 * entries of the target observable, and synchronization resumes.
	 * </ul>

Lines 7-12 Link Here

(-)src/org/eclipse/core/internal/databinding/observable/ValidatedObservableSet.java (-31 / +61 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* Matthew Hall - initial API and implementation (bug 218269)	9	* Matthew Hall - initial API and implementation (bug 218269)
		10	* Matthew Hall - bug 248868
		11	* Ovidio Mallo - bug 248868
10	******************************************************************************/	12	******************************************************************************/
11		13
12	package org.eclipse.core.internal.databinding.observable;	14	package org.eclipse.core.internal.databinding.observable;
Lines 40-50 Link Here
40	private IObservableValue validationStatus;	42	private IObservableValue validationStatus;
41		43
42	// Only true when out of sync with target due to validation status	44	// Only true when out of sync with target due to validation status
43	private boolean stale;	45	private boolean dirty = false;
44		46
45	// True when validation status changes from invalid to valid.	47	// True when validaton status changes from invalid or stale to valid and
		48	// non-stale.
46	private boolean computeNextDiff = false;	49	private boolean computeNextDiff = false;
47		50
		51	private boolean stale;
		52
48	private boolean updatingTarget = false;	53	private boolean updatingTarget = false;
49		54
50	private ISetChangeListener targetChangeListener = new ISetChangeListener() {	55	private ISetChangeListener targetChangeListener = new ISetChangeListener() {
Lines 52-62 Link Here
52	if (updatingTarget)	57	if (updatingTarget)
53	return;	58	return;
54	IStatus status = (IStatus) validationStatus.getValue();	59	IStatus status = (IStatus) validationStatus.getValue();
55	if (isValid(status)) {	60	if (!validationStatus.isStale() && isValid(status)) {
56	if (stale) {	61	// Update the staleness state. Note that we do not care at this
57	// this.stale means we are out of sync with target,	62	// point whether that state changes from stale to non-stale
		63	// since we are always firing a change event below anyway.
		64	stale = target.isStale() \|\| validationStatus.isStale();
		65
		66	if (dirty) {
		67	// this.dirty means we are out of sync with target,
58	// so reset wrapped list to exactly mirror target	68	// so reset wrapped list to exactly mirror target
59	stale = false;	69	dirty = false;
60	updateWrappedSet(new HashSet(target));	70	updateWrappedSet(new HashSet(target));
61	} else {	71	} else {
62	SetDiff diff = event.diff;	72	SetDiff diff = event.diff;
Lines 68-101 Link Here
68	fireSetChange(diff);	78	fireSetChange(diff);
69	}	79	}
70	} else {	80	} else {
		81	// We are not propagating a received change from the target list
		82	// so we become dirty and stale.
		83	dirty = true;
71	makeStale();	84	makeStale();
72	}	85	}
73	}	86	}
74	};	87	};
75		88
76	private IStaleListener targetStaleListener = new IStaleListener() {
77	public void handleStale(StaleEvent staleEvent) {
78	fireStale();
79	}
80	};
81
82	private IValueChangeListener validationStatusChangeListener = new IValueChangeListener() {	89	private IValueChangeListener validationStatusChangeListener = new IValueChangeListener() {
83	public void handleValueChange(ValueChangeEvent event) {	90	public void handleValueChange(ValueChangeEvent event) {
84	IStatus oldStatus = (IStatus) event.diff.getOldValue();
85	IStatus newStatus = (IStatus) event.diff.getNewValue();	91	IStatus newStatus = (IStatus) event.diff.getNewValue();
86	if (stale && !isValid(oldStatus) && isValid(newStatus)) {	92	if (!validationStatus.isStale() && isValid(newStatus)) {
87	// this.stale means we are out of sync with target,	93	// Update the staleness state and remember whether we were stale
88	// reset wrapped set to exactly mirror target	94	// before.
89	stale = false;	95	boolean wasStale = stale;
90	updateWrappedSet(new HashSet(target));	96	stale = target.isStale() \|\| validationStatus.isStale();
91		97
92	// If the validation status becomes valid because of a change in	98	if (dirty) {
93	// target observable	99	// this.dirty means we are out of sync with target,
94	computeNextDiff = true;	100	// reset wrapped set to exactly mirror target
		101	dirty = false;
		102	updateWrappedSet(new HashSet(target));
		103
		104	// If the validation status becomes valid because of a
		105	// change in target observable
		106	computeNextDiff = true;
		107	} else {
		108	// If we are becoming unstale, we must fire a change event
		109	// to signal this.
		110	if (wasStale && !stale) {
		111	fireSetChange(Diffs.createSetDiff(
		112	Collections.EMPTY_SET, Collections.EMPTY_SET));
		113	}
		114	}
95	}	115	}
96	}	116	}
97	};	117	};
98		118
		119	private IStaleListener staleListener = new IStaleListener() {
		120	public void handleStale(StaleEvent staleEvent) {
		121	makeStale();
		122	}
		123	};
		124
		125	private static boolean isValid(IStatus status) {
		126	return !status.matches(IStatus.CANCEL \| IStatus.ERROR);
		127	}
		128
99	/**	129	/**
100	* @param target	130	* @param target
101	* @param validationStatus	131	* @param validationStatus
Lines 110-118 Link Here
110	"Target and validation status observables must be on the same realm"); //$NON-NLS-1$	140	"Target and validation status observables must be on the same realm"); //$NON-NLS-1$
111	this.target = target;	141	this.target = target;
112	this.validationStatus = validationStatus;	142	this.validationStatus = validationStatus;
		143	this.stale = target.isStale() \|\| validationStatus.isStale();
113	target.addSetChangeListener(targetChangeListener);	144	target.addSetChangeListener(targetChangeListener);
114	target.addStaleListener(targetStaleListener);	145	target.addStaleListener(staleListener);
115	validationStatus.addValueChangeListener(validationStatusChangeListener);	146	validationStatus.addValueChangeListener(validationStatusChangeListener);
		147	validationStatus.addStaleListener(staleListener);
116	}	148	}
117		149
118	private void updateWrappedSet(Set newSet) {	150	private void updateWrappedSet(Set newSet) {
Lines 122-131 Link Here
122	fireSetChange(diff);	154	fireSetChange(diff);
123	}	155	}
124		156
125	private static boolean isValid(IStatus status) {
126	return status.isOK() \|\| status.matches(IStatus.INFO \| IStatus.WARNING);
127	}
128
129	private void applyDiff(SetDiff diff, Set set) {	157	private void applyDiff(SetDiff diff, Set set) {
130	for (Iterator iterator = diff.getRemovals().iterator(); iterator	158	for (Iterator iterator = diff.getRemovals().iterator(); iterator
131	.hasNext();) {	159	.hasNext();) {
Lines 147-158 Link Here
147	private void updateTargetSet(SetDiff diff) {	175	private void updateTargetSet(SetDiff diff) {
148	updatingTarget = true;	176	updatingTarget = true;
149	try {	177	try {
150	if (stale) {	178	if (dirty) {
151	stale = false;	179	dirty = false;
152	applyDiff(Diffs.computeSetDiff(target, wrappedSet), target);	180	applyDiff(Diffs.computeSetDiff(target, wrappedSet), target);
153	} else {	181	} else {
154	applyDiff(diff, target);	182	applyDiff(diff, target);
155	}	183	}
		184	stale = target.isStale() \|\| validationStatus.isStale();
156	} finally {	185	} finally {
157	updatingTarget = false;	186	updatingTarget = false;
158	}	187	}
Lines 160-166 Link Here
160		189
161	public boolean isStale() {	190	public boolean isStale() {
162	getterCalled();	191	getterCalled();
163	return stale \|\| target.isStale();	192	return stale;
164	}	193	}
165		194
166	public boolean add(Object o) {	195	public boolean add(Object o) {
Lines 262-270 Link Here
262		291
263	public synchronized void dispose() {	292	public synchronized void dispose() {
264	target.removeSetChangeListener(targetChangeListener);	293	target.removeSetChangeListener(targetChangeListener);
265	target.removeStaleListener(targetStaleListener);	294	target.removeStaleListener(staleListener);
266	validationStatus	295	validationStatus
267	.removeValueChangeListener(validationStatusChangeListener);	296	.removeValueChangeListener(validationStatusChangeListener);
		297	validationStatus.removeStaleListener(staleListener);
268	super.dispose();	298	super.dispose();
269	}	299	}
270	}	300	}

Lines 7-12 Link Here

(-)src/org/eclipse/core/internal/databinding/observable/ValidatedObservableMap.java (-28 / +60 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* Matthew Hall - initial API and implementation (bug 218269)	9	* Matthew Hall - initial API and implementation (bug 218269)
		10	* Matthew Hall - bug 248868
		11	* Ovidio Mallo - bug 248868
10	******************************************************************************/	12	******************************************************************************/
11		13
12	package org.eclipse.core.internal.databinding.observable;	14	package org.eclipse.core.internal.databinding.observable;
Lines 39-49 Link Here
39	private IObservableValue validationStatus;	41	private IObservableValue validationStatus;
40		42
41	// Only true when out of sync with target due to validation status	43	// Only true when out of sync with target due to validation status
42	private boolean stale;	44	private boolean dirty = false;
43		45
44	// True when validation status changes from invalid to valid.	46	// True when validaton status changes from invalid or stale to valid and
		47	// non-stale.
45	private boolean computeNextDiff = false;	48	private boolean computeNextDiff = false;
46		49
		50	private boolean stale;
		51
47	private boolean updatingTarget = false;	52	private boolean updatingTarget = false;
48		53
49	private IMapChangeListener targetChangeListener = new IMapChangeListener() {	54	private IMapChangeListener targetChangeListener = new IMapChangeListener() {
Lines 51-61 Link Here
51	if (updatingTarget)	56	if (updatingTarget)
52	return;	57	return;
53	IStatus status = (IStatus) validationStatus.getValue();	58	IStatus status = (IStatus) validationStatus.getValue();
54	if (isValid(status)) {	59	if (!validationStatus.isStale() && isValid(status)) {
55	if (stale) {	60	// Update the staleness state. Note that we do not care at this
56	// this.stale means we are out of sync with target,	61	// point whether that state changes from stale to non-stale
		62	// since we are always firing a change event below anyway.
		63	stale = target.isStale() \|\| validationStatus.isStale();
		64
		65	if (dirty) {
		66	// this.dirty means we are out of sync with target,
57	// so reset wrapped list to exactly mirror target	67	// so reset wrapped list to exactly mirror target
58	stale = false;	68	dirty = false;
59	updateWrappedMap(new HashMap(target));	69	updateWrappedMap(new HashMap(target));
60	} else {	70	} else {
61	MapDiff diff = event.diff;	71	MapDiff diff = event.diff;
Lines 67-100 Link Here
67	fireMapChange(diff);	77	fireMapChange(diff);
68	}	78	}
69	} else {	79	} else {
		80	// We are not propagating a received change from the target list
		81	// so we become dirty and stale.
		82	dirty = true;
70	makeStale();	83	makeStale();
71	}	84	}
72	}	85	}
73	};	86	};
74		87
75	private IStaleListener targetStaleListener = new IStaleListener() {
76	public void handleStale(StaleEvent staleEvent) {
77	fireStale();
78	}
79	};
80
81	private IValueChangeListener validationStatusChangeListener = new IValueChangeListener() {	88	private IValueChangeListener validationStatusChangeListener = new IValueChangeListener() {
82	public void handleValueChange(ValueChangeEvent event) {	89	public void handleValueChange(ValueChangeEvent event) {
83	IStatus oldStatus = (IStatus) event.diff.getOldValue();
84	IStatus newStatus = (IStatus) event.diff.getNewValue();	90	IStatus newStatus = (IStatus) event.diff.getNewValue();
85	if (stale && !isValid(oldStatus) && isValid(newStatus)) {	91	if (!validationStatus.isStale() && isValid(newStatus)) {
86	// this.stale means we are out of sync with target,	92	// Update the staleness state and remember whether we were stale
87	// reset wrapped map to exactly mirror target	93	// before.
88	stale = false;	94	boolean wasStale = stale;
89	updateWrappedMap(new HashMap(target));	95	stale = target.isStale() \|\| validationStatus.isStale();
90		96
91	// If the validation status becomes valid because of a change in	97	if (dirty) {
92	// target observable	98	// this.dirty means we are out of sync with target,
93	computeNextDiff = true;	99	// reset wrapped map to exactly mirror target
		100	dirty = false;
		101	updateWrappedMap(new HashMap(target));
		102
		103	// If the validation status becomes valid because of a
		104	// change in target observable
		105	computeNextDiff = true;
		106	} else {
		107	// If we are becoming unstale, we must fire a change event
		108	// to signal this.
		109	if (wasStale && !stale) {
		110	fireMapChange(Diffs.createMapDiff(
		111	Collections.EMPTY_SET, Collections.EMPTY_SET,
		112	Collections.EMPTY_SET, Collections.EMPTY_MAP,
		113	Collections.EMPTY_MAP));
		114	}
		115	}
94	}	116	}
95	}	117	}
96	};	118	};
97		119
		120	private IStaleListener staleListener = new IStaleListener() {
		121	public void handleStale(StaleEvent staleEvent) {
		122	makeStale();
		123	}
		124	};
		125
98	/**	126	/**
99	* @param target	127	* @param target
100	* @param validationStatus	128	* @param validationStatus
Lines 109-117 Link Here
109	"Target and validation status observables must be on the same realm"); //$NON-NLS-1$	137	"Target and validation status observables must be on the same realm"); //$NON-NLS-1$
110	this.target = target;	138	this.target = target;
111	this.validationStatus = validationStatus;	139	this.validationStatus = validationStatus;
		140	this.stale = target.isStale() \|\| validationStatus.isStale();
112	target.addMapChangeListener(targetChangeListener);	141	target.addMapChangeListener(targetChangeListener);
113	target.addStaleListener(targetStaleListener);	142	target.addStaleListener(staleListener);
114	validationStatus.addValueChangeListener(validationStatusChangeListener);	143	validationStatus.addValueChangeListener(validationStatusChangeListener);
		144	validationStatus.addStaleListener(staleListener);
115	}	145	}
116		146
117	private void updateWrappedMap(Map newMap) {	147	private void updateWrappedMap(Map newMap) {
Lines 122-128 Link Here
122	}	152	}
123		153
124	private static boolean isValid(IStatus status) {	154	private static boolean isValid(IStatus status) {
125	return status.isOK() \|\| status.matches(IStatus.INFO \| IStatus.WARNING);	155	return !status.matches(IStatus.CANCEL \| IStatus.ERROR);
126	}	156	}
127		157
128	private void applyDiff(MapDiff diff, Map map) {	158	private void applyDiff(MapDiff diff, Map map) {
Lines 151-162 Link Here
151	private void updateTargetMap(MapDiff diff) {	181	private void updateTargetMap(MapDiff diff) {
152	updatingTarget = true;	182	updatingTarget = true;
153	try {	183	try {
154	if (stale) {	184	if (dirty) {
155	stale = false;	185	dirty = false;
156	applyDiff(Diffs.computeMapDiff(target, wrappedMap), target);	186	applyDiff(Diffs.computeMapDiff(target, wrappedMap), target);
157	} else {	187	} else {
158	applyDiff(diff, target);	188	applyDiff(diff, target);
159	}	189	}
		190	stale = target.isStale() \|\| validationStatus.isStale();
160	} finally {	191	} finally {
161	updatingTarget = false;	192	updatingTarget = false;
162	}	193	}
Lines 164-170 Link Here
164		195
165	public boolean isStale() {	196	public boolean isStale() {
166	getterCalled();	197	getterCalled();
167	return stale \|\| target.isStale();	198	return stale;
168	}	199	}
169		200
170	public void clear() {	201	public void clear() {
Lines 220-228 Link Here
220		251
221	public synchronized void dispose() {	252	public synchronized void dispose() {
222	target.removeMapChangeListener(targetChangeListener);	253	target.removeMapChangeListener(targetChangeListener);
223	target.removeStaleListener(targetStaleListener);	254	target.removeStaleListener(staleListener);
224	validationStatus	255	validationStatus
225	.removeValueChangeListener(validationStatusChangeListener);	256	.removeValueChangeListener(validationStatusChangeListener);
		257	validationStatus.removeStaleListener(staleListener);
226	super.dispose();	258	super.dispose();
227	}	259	}
228	}	260	}

Lines 7-12 Link Here

(-)src/org/eclipse/core/internal/databinding/observable/ValidatedObservableList.java (-33 / +62 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* Matthew Hall - initial API and implementation (bug 218269)	9	* Matthew Hall - initial API and implementation (bug 218269)
		10	* Matthew Hall - bug 248868
		11	* Ovidio Mallo - bug 248868
10	******************************************************************************/	12	******************************************************************************/
11		13
12	package org.eclipse.core.internal.databinding.observable;	14	package org.eclipse.core.internal.databinding.observable;
Lines 20-26 Link Here
20		22
21	import org.eclipse.core.databinding.observable.Diffs;	23	import org.eclipse.core.databinding.observable.Diffs;
22	import org.eclipse.core.databinding.observable.IStaleListener;	24	import org.eclipse.core.databinding.observable.IStaleListener;
23	import org.eclipse.core.databinding.observable.ObservableTracker;
24	import org.eclipse.core.databinding.observable.StaleEvent;	25	import org.eclipse.core.databinding.observable.StaleEvent;
25	import org.eclipse.core.databinding.observable.list.IListChangeListener;	26	import org.eclipse.core.databinding.observable.list.IListChangeListener;
26	import org.eclipse.core.databinding.observable.list.IObservableList;	27	import org.eclipse.core.databinding.observable.list.IObservableList;
Lines 44-54 Link Here
44	private IObservableValue validationStatus;	45	private IObservableValue validationStatus;
45		46
46	// Only true when out of sync with target due to validation status	47	// Only true when out of sync with target due to validation status
47	private boolean stale;	48	private boolean dirty = false;
48		49
49	// True when validaton status changes from invalid to valid.	50	// True when validaton status changes from invalid or stale to valid and
		51	// non-stale.
50	private boolean computeNextDiff = false;	52	private boolean computeNextDiff = false;
51		53
		54	private boolean stale;
		55
52	private boolean updatingTarget = false;	56	private boolean updatingTarget = false;
53		57
54	private IListChangeListener targetChangeListener = new IListChangeListener() {	58	private IListChangeListener targetChangeListener = new IListChangeListener() {
Lines 56-66 Link Here
56	if (updatingTarget)	60	if (updatingTarget)
57	return;	61	return;
58	IStatus status = (IStatus) validationStatus.getValue();	62	IStatus status = (IStatus) validationStatus.getValue();
59	if (isValid(status)) {	63	if (!validationStatus.isStale() && isValid(status)) {
60	if (stale) {	64	// Update the staleness state. Note that we do not care at this
61	// this.stale means we are out of sync with target,	65	// point whether that state changes from stale to non-stale
		66	// since we are always firing a change event below anyway.
		67	stale = target.isStale() \|\| validationStatus.isStale();
		68
		69	if (dirty) {
		70	// this.dirty means we are out of sync with target,
62	// so reset wrapped list to exactly mirror target	71	// so reset wrapped list to exactly mirror target
63	stale = false;	72	dirty = false;
64	updateWrappedList(new ArrayList(target));	73	updateWrappedList(new ArrayList(target));
65	} else {	74	} else {
66	ListDiff diff = event.diff;	75	ListDiff diff = event.diff;
Lines 72-109 Link Here
72	fireListChange(diff);	81	fireListChange(diff);
73	}	82	}
74	} else {	83	} else {
		84	// We are not propagating a received change from the target list
		85	// so we become dirty and stale.
		86	dirty = true;
75	makeStale();	87	makeStale();
76	}	88	}
77	}	89	}
78	};	90	};
79		91
80	private static boolean isValid(IStatus status) {
81	return status.isOK() \|\| status.matches(IStatus.INFO \| IStatus.WARNING);
82	}
83
84	private IStaleListener targetStaleListener = new IStaleListener() {
85	public void handleStale(StaleEvent staleEvent) {
86	fireStale();
87	}
88	};
89
90	private IValueChangeListener validationStatusChangeListener = new IValueChangeListener() {	92	private IValueChangeListener validationStatusChangeListener = new IValueChangeListener() {
91	public void handleValueChange(ValueChangeEvent event) {	93	public void handleValueChange(ValueChangeEvent event) {
92	IStatus oldStatus = (IStatus) event.diff.getOldValue();
93	IStatus newStatus = (IStatus) event.diff.getNewValue();	94	IStatus newStatus = (IStatus) event.diff.getNewValue();
94	if (stale && !isValid(oldStatus) && isValid(newStatus)) {	95	if (!validationStatus.isStale() && isValid(newStatus)) {
95	// this.stale means we are out of sync with target,	96	// Update the staleness state and remember whether we were stale
96	// reset wrapped list to exactly mirror target	97	// before.
97	stale = false;	98	boolean wasStale = stale;
98	updateWrappedList(new ArrayList(target));	99	stale = target.isStale() \|\| validationStatus.isStale();
99		100
100	// If the validation status becomes valid because of a change in	101	if (dirty) {
101	// target observable	102	// this.dirty means we are out of sync with target,
102	computeNextDiff = true;	103	// reset wrapped list to exactly mirror target
		104	dirty = false;
		105	updateWrappedList(new ArrayList(target));
		106
		107	// If the validation status becomes valid because of a
		108	// change in target observable
		109	computeNextDiff = true;
		110	} else {
		111	// If we are becoming unstale, we must fire a change event
		112	// to signal this.
		113	if (wasStale && !stale) {
		114	fireListChange(Diffs
		115	.createListDiff(new ListDiffEntry[0]));
		116	}
		117	}
103	}	118	}
104	}	119	}
105	};	120	};
106		121
		122	private IStaleListener staleListener = new IStaleListener() {
		123	public void handleStale(StaleEvent staleEvent) {
		124	makeStale();
		125	}
		126	};
		127
		128	private static boolean isValid(IStatus status) {
		129	return !status.matches(IStatus.CANCEL \| IStatus.ERROR);
		130	}
		131
107	/**	132	/**
108	* @param target	133	* @param target
109	* @param validationStatus	134	* @param validationStatus
Lines 118-126 Link Here
118	"Target and validation status observables must be on the same realm"); //$NON-NLS-1$	143	"Target and validation status observables must be on the same realm"); //$NON-NLS-1$
119	this.target = target;	144	this.target = target;
120	this.validationStatus = validationStatus;	145	this.validationStatus = validationStatus;
		146	this.stale = target.isStale() \|\| validationStatus.isStale();
121	target.addListChangeListener(targetChangeListener);	147	target.addListChangeListener(targetChangeListener);
122	target.addStaleListener(targetStaleListener);	148	target.addStaleListener(staleListener);
123	validationStatus.addValueChangeListener(validationStatusChangeListener);	149	validationStatus.addValueChangeListener(validationStatusChangeListener);
		150	validationStatus.addStaleListener(staleListener);
124	}	151	}
125		152
126	private void makeStale() {	153	private void makeStale() {
Lines 133-144 Link Here
133	private void updateTargetList(ListDiff diff) {	160	private void updateTargetList(ListDiff diff) {
134	updatingTarget = true;	161	updatingTarget = true;
135	try {	162	try {
136	if (stale) {	163	if (dirty) {
137	stale = false;	164	dirty = false;
138	applyDiff(Diffs.computeListDiff(target, wrappedList), target);	165	applyDiff(Diffs.computeListDiff(target, wrappedList), target);
139	} else {	166	} else {
140	applyDiff(diff, target);	167	applyDiff(diff, target);
141	}	168	}
		169	stale = target.isStale() \|\| validationStatus.isStale();
142	} finally {	170	} finally {
143	updatingTarget = false;	171	updatingTarget = false;
144	}	172	}
Lines 162-169 Link Here
162	}	190	}
163		191
164	public boolean isStale() {	192	public boolean isStale() {
165	ObservableTracker.getterCalled(this);	193	getterCalled();
166	return stale \|\| target.isStale();	194	return stale;
167	}	195	}
168		196
169	public void add(int index, Object element) {	197	public void add(int index, Object element) {
Lines 385-393 Link Here
385		413
386	public synchronized void dispose() {	414	public synchronized void dispose() {
387	target.removeListChangeListener(targetChangeListener);	415	target.removeListChangeListener(targetChangeListener);
388	target.removeStaleListener(targetStaleListener);	416	target.removeStaleListener(staleListener);
389	validationStatus	417	validationStatus
390	.removeValueChangeListener(validationStatusChangeListener);	418	.removeValueChangeListener(validationStatusChangeListener);
		419	validationStatus.removeStaleListener(staleListener);
391	super.dispose();	420	super.dispose();
392	}	421	}
393	}	422	}




 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 218269)
 *     Matthew Hall - bug 248868
 *     Ovidio Mallo - bug 248868
 ******************************************************************************/

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


/**
 * An {@link IObservableValue} wrapper that stays in sync with the target
 * observable as long as a given validation status is valid and not stale.
 * <ul>
 * <li>While status is valid and not stale, ValidatedObservableValue stays in
 * sync with its target.
 * <li>When status becomes invalid or stale, ValidatedObservableValue will
 * retain the last valid value of its target.
 * <li>While status is invalid or stale, changes in the target observable cause
 * ValidatedObservableValue to fire a stale event, to indicate that changes are
 * pending.
 * <li>When status becomes valid and not stale, pending value changes are
 * performed (if any) and synchronization resumes.
 * </ul>
 * <p>
 * Note:
 * <ul>
 * <li>By default, a status is valid if its {@link IStatus#getSeverity()
 * severity} is {@link IStatus#OK OK}, {@link IStatus#INFO INFO}, or
 * {@link IStatus#WARNING WARNING}
 * <li>Calls to {@link #setValue(Object)} on the validated observable changes
 * the value regardless of the validation status.
 * <li>This class will not forward {@link ValueChangingEvent} events from a

			if (updatingTarget)
				return;
			IStatus status = (IStatus) validationStatus.getValue();
			if (!validationStatus.isStale() && isValid(status))
				internalSetValue(event.diff.getNewValue(), false);
			else
				makeStale();
		}
	};

	private static boolean isValid(IStatus status) {
		return status.isOK() || status.matches(IStatus.INFO | IStatus.WARNING);
	}

	private IStaleListener targetStaleListener = new IStaleListener() {
		public void handleStale(StaleEvent staleEvent) {
			fireStale();
		}
	};

	private IValueChangeListener validationStatusChangeListener = new IValueChangeListener() {
		public void handleValueChange(ValueChangeEvent event) {
			IStatus oldStatus = (IStatus) event.diff.getOldValue();
			IStatus newStatus = (IStatus) event.diff.getNewValue();
			if (!validationStatus.isStale() && isValid(newStatus)) {
				internalSetValue(target.getValue(), false);
			}
		}
	};

	private IStaleListener staleListener = new IStaleListener() {
		public void handleStale(StaleEvent staleEvent) {
			makeStale();
		}
	};

	private static boolean isValid(IStatus status) {
		return !status.matches(IStatus.CANCEL | IStatus.ERROR);
	}

	/**
	 * Constructs an observable value
	 * 

		this.target = target;
		this.validationStatus = validationStatus;
		this.cachedValue = target.getValue();
		this.stale = target.isStale() || validationStatus.isStale();

		target.addValueChangeListener(targetChangeListener);
		target.addStaleListener(staleListener);
		validationStatus.addValueChangeListener(validationStatusChangeListener);
		validationStatus.addStaleListener(staleListener);
	}

	private void makeStale() {


	public boolean isStale() {
		ObservableTracker.getterCalled(this);
		return stale;
	}

	protected Object doGetValue() {

	}

	private void internalSetValue(Object value, boolean updateTarget) {
		boolean wasStale = this.stale;
		Object oldValue = cachedValue;
		cachedValue = value;
		if (updateTarget) {

				updatingTarget = false;
			}
		}
		stale = target.isStale() || validationStatus.isStale();
		if ((wasStale && !stale) || !Util.equals(oldValue, cachedValue))
			fireValueChange(Diffs.createValueDiff(oldValue, cachedValue));
	}



	public synchronized void dispose() {
		target.removeValueChangeListener(targetChangeListener);
		target.removeStaleListener(staleListener);
		validationStatus
				.removeValueChangeListener(validationStatusChangeListener);
		validationStatus.removeStaleListener(staleListener);
		super.dispose();
	}
}

Return to bug 248868

Added Link Here

(-)src/org/eclipse/core/tests/internal/databinding/observable/ValidatedObservableMapTest.java (+144 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 Ovidio Mallo 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	* Ovidio Mallo - initial API and implementation (bug 248868)
10	******************************************************************************/
11
12	package org.eclipse.core.tests.internal.databinding.observable;
13
14	import junit.framework.Test;
15	import junit.framework.TestSuite;
16
17	import org.eclipse.core.databinding.observable.Diffs;
18	import org.eclipse.core.databinding.observable.ObservableTracker;
19	import org.eclipse.core.databinding.observable.map.IObservableMap;
20	import org.eclipse.core.databinding.observable.map.WritableMap;
21	import org.eclipse.core.databinding.observable.value.WritableValue;
22	import org.eclipse.core.databinding.validation.ValidationStatus;
23	import org.eclipse.core.internal.databinding.observable.ValidatedObservableMap;
24	import org.eclipse.core.runtime.IStatus;
25	import org.eclipse.jface.databinding.conformance.util.MapChangeEventTracker;
26	import org.eclipse.jface.databinding.conformance.util.StaleEventTracker;
27	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
28
29	public class ValidatedObservableMapTest extends AbstractDefaultRealmTestCase {
30	private ValidatedObservableMap validated;
31	private IObservableMap target;
32	private ValidationObservableValue validationStatus;
33
34	protected void setUp() throws Exception {
35	super.setUp();
36
37	target = new WritableMap();
38	validationStatus = new ValidationObservableValue();
39	validated = new ValidatedObservableMap(target, validationStatus);
40	}
41
42	public void testIsStale_WhenStatusIsStale() {
43	MapChangeEventTracker validatedChangeTracker = MapChangeEventTracker
44	.observe(validated);
45	StaleEventTracker validatedStaleTracker = StaleEventTracker
46	.observe(validated);
47
48	assertFalse(validationStatus.isStale());
49	assertFalse(validated.isStale());
50	assertEquals(0, validatedChangeTracker.count);
51	assertEquals(0, validatedStaleTracker.count);
52
53	// Become stale and check that we receive a stale event.
54	validationStatus.setStale(true);
55
56	assertTrue(validationStatus.isStale());
57	assertTrue(validated.isStale());
58	assertEquals(0, validatedChangeTracker.count);
59	assertEquals(1, validatedStaleTracker.count); // +1
60
61	// Become unstale again and check that we receive a change event.
62	validationStatus.setStale(false);
63
64	assertFalse(validationStatus.isStale());
65	assertFalse(validated.isStale());
66	assertEquals(1, validatedChangeTracker.count); // +1
67	assertEquals(1, validatedStaleTracker.count);
68	}
69
70	public void testEvents_WhenStatusIsStale() {
71	MapChangeEventTracker validatedChangeTracker = MapChangeEventTracker
72	.observe(validated);
73	StaleEventTracker validatedStaleTracker = StaleEventTracker
74	.observe(validated);
75
76	assertFalse(validationStatus.isStale());
77	assertFalse(validated.isStale());
78	assertEquals(0, validatedChangeTracker.count);
79	assertEquals(0, validatedStaleTracker.count);
80
81	// Become stale and check that we receive a stale event.
82	validationStatus.setStale(true);
83
84	assertTrue(validationStatus.isStale());
85	assertTrue(validated.isStale());
86	assertEquals(0, validatedChangeTracker.count);
87	assertEquals(1, validatedStaleTracker.count); // +1
88
89	// Changes to the target observable should not be propagated while the
90	// validation is stale.
91	target.put(new Object(), new Object());
92
93	assertEquals(0, validatedChangeTracker.count);
94	assertEquals(1, validatedStaleTracker.count);
95
96	// Changes to the validated observable should be propagated while the
97	// validation is stale but we remain stale.
98	validated.put(new Object(), new Object());
99
100	assertTrue(validated.isStale());
101	assertEquals(1, validatedChangeTracker.count); // +1
102	assertEquals(1, validatedStaleTracker.count);
103
104	// Finally, become unstale and check that we receive a change event.
105	validationStatus.setStale(false);
106
107	assertFalse(validationStatus.isStale());
108	assertFalse(validated.isStale());
109	assertEquals(2, validatedChangeTracker.count); // +1
110	assertEquals(1, validatedStaleTracker.count);
111	}
112
113	public static Test suite() {
114	TestSuite suite = new TestSuite(ValidatedObservableMapTest.class
115	.getName());
116	suite.addTestSuite(ValidatedObservableMapTest.class);
117	return suite;
118	}
119
120	private static class ValidationObservableValue extends WritableValue {
121	private boolean stale = false;
122
123	public ValidationObservableValue() {
124	super(ValidationStatus.ok(), IStatus.class);
125	}
126
127	public boolean isStale() {
128	ObservableTracker.getterCalled(this);
129	return stale;
130	}
131
132	public void setStale(boolean stale) {
133	if (this.stale != stale) {
134	this.stale = stale;
135	if (stale) {
136	fireStale();
137	} else {
138	fireValueChange(Diffs.createValueDiff(doGetValue(),
139	doGetValue()));
140	}
141	}
142	}
143	}
144	}

Lines 9-15 Link Here

(-)src/org/eclipse/core/databinding/validation/MultiValidator.java (-25 / +29 lines)
9	* Matthew Hall - initial API and implementation (bug 218269)	9	* Matthew Hall - initial API and implementation (bug 218269)
10	* Boris Bokowski - bug 218269	10	* Boris Bokowski - bug 218269
11	* Matthew Hall - bug 237884, 240590	11	* Matthew Hall - bug 237884, 240590
12	* Ovidio Mallo - bug 238909	12	* Ovidio Mallo - bugs 238909, 248868
13	******************************************************************************/	13	******************************************************************************/
14		14
15	package org.eclipse.core.databinding.validation;	15	package org.eclipse.core.databinding.validation;
Lines 265-280 Link Here
265		265
266	/**	266	/**
267	* Returns a wrapper {@link IObservableValue} which stays in sync with the	267	* Returns a wrapper {@link IObservableValue} which stays in sync with the
268	* given target observable only when the validation status is valid.	268	* given target observable only when the validation status is valid and not
269	* Statuses of {@link IStatus#OK OK}, {@link IStatus#INFO INFO} or	269	* stale. Statuses of {@link IStatus#OK OK}, {@link IStatus#INFO INFO} or
270	* {@link IStatus#WARNING WARNING} severity are considered valid.	270	* {@link IStatus#WARNING WARNING} severity are considered valid.
271	* <p>	271	* <p>
272	* The wrapper behaves as follows with respect to the validation status:	272	* The wrapper behaves as follows with respect to the validation status:
273	* <ul>	273	* <ul>
274	* <li>While valid, the wrapper stays in sync with its target observable.	274	* <li>While valid and not stale, the wrapper stays in sync with its target
275	* <li>While invalid, the wrapper's value is the target observable's last	275	* observable.
276	* valid value. If the target changes value, a stale event is fired	276	* <li>While invalid or stale, the wrapper's value is the target
277	* signaling that a change is pending.	277	* observable's last valid value. If the target changes value, a stale event
		278	* is fired signaling that a change is pending.
278	* <li>When status changes from invalid to valid, the wrapper takes the	279	* <li>When status changes from invalid to valid, the wrapper takes the
279	* value of the target observable, and synchronization resumes.	280	* value of the target observable, and synchronization resumes.
280	* </ul>	281	* </ul>
Lines 292-307 Link Here
292		293
293	/**	294	/**
294	* Returns a wrapper {@link IObservableList} which stays in sync with the	295	* Returns a wrapper {@link IObservableList} which stays in sync with the
295	* given target observable only when the validation status is valid.	296	* given target observable only when the validation status is valid and not
296	* Statuses of {@link IStatus#OK OK}, {@link IStatus#INFO INFO} or	297	* stale. Statuses of {@link IStatus#OK OK}, {@link IStatus#INFO INFO} or
297	* {@link IStatus#WARNING WARNING} severity are considered valid.	298	* {@link IStatus#WARNING WARNING} severity are considered valid.
298	* <p>	299	* <p>
299	* The wrapper behaves as follows with respect to the validation status:	300	* The wrapper behaves as follows with respect to the validation status:
300	* <ul>	301	* <ul>
301	* <li>While valid, the wrapper stays in sync with its target observable.	302	* <li>While valid and not stale, the wrapper stays in sync with its target
302	* <li>While invalid, the wrapper's elements are the target observable's	303	* observable.
303	* last valid elements. If the target changes elements, a stale event is	304	* <li>While invalid or stale, the wrapper's elements are the target
304	* fired signaling that a change is pending.	305	* observable's last valid elements. If the target changes elements, a stale
		306	* event is fired signaling that a change is pending.
305	* <li>When status changes from invalid to valid, the wrapper takes the	307	* <li>When status changes from invalid to valid, the wrapper takes the
306	* elements of the target observable, and synchronization resumes.	308	* elements of the target observable, and synchronization resumes.
307	* </ul>	309	* </ul>
Lines 319-334 Link Here
319		321
320	/**	322	/**
321	* Returns a wrapper {@link IObservableSet} which stays in sync with the	323	* Returns a wrapper {@link IObservableSet} which stays in sync with the
322	* given target observable only when the validation status is valid.	324	* given target observable only when the validation status is valid and not
323	* Statuses of {@link IStatus#OK OK}, {@link IStatus#INFO INFO} or	325	* stale. Statuses of {@link IStatus#OK OK}, {@link IStatus#INFO INFO} or
324	* {@link IStatus#WARNING WARNING} severity are considered valid.	326	* {@link IStatus#WARNING WARNING} severity are considered valid.
325	* <p>	327	* <p>
326	* The wrapper behaves as follows with respect to the validation status:	328	* The wrapper behaves as follows with respect to the validation status:
327	* <ul>	329	* <ul>
328	* <li>While valid, the wrapper stays in sync with its target observable.	330	* <li>While valid and not stale, the wrapper stays in sync with its target
329	* <li>While invalid, the wrapper's elements are the target observable's	331	* observable.
330	* last valid elements. If the target changes elements, a stale event is	332	* <li>While invalid or stale, the wrapper's elements are the target
331	* fired signaling that a change is pending.	333	* observable's last valid elements. If the target changes elements, a stale
		334	* event is fired signaling that a change is pending.
332	* <li>When status changes from invalid to valid, the wrapper takes the	335	* <li>When status changes from invalid to valid, the wrapper takes the
333	* elements of the target observable, and synchronization resumes.	336	* elements of the target observable, and synchronization resumes.
334	* </ul>	337	* </ul>
Lines 346-361 Link Here
346		349
347	/**	350	/**
348	* Returns a wrapper {@link IObservableMap} which stays in sync with the	351	* Returns a wrapper {@link IObservableMap} which stays in sync with the
349	* given target observable only when the validation status is valid.	352	* given target observable only when the validation status is valid and not
350	* Statuses of {@link IStatus#OK OK}, {@link IStatus#INFO INFO} or	353	* stale. Statuses of {@link IStatus#OK OK}, {@link IStatus#INFO INFO} or
351	* {@link IStatus#WARNING WARNING} severity are considered valid.	354	* {@link IStatus#WARNING WARNING} severity are considered valid.
352	* <p>	355	* <p>
353	* The wrapper behaves as follows with respect to the validation status:	356	* The wrapper behaves as follows with respect to the validation status:
354	* <ul>	357	* <ul>
355	* <li>While valid, the wrapper stays in sync with its target observable.	358	* <li>While valid and not stale, the wrapper stays in sync with its target
356	* <li>While invalid, the wrapper's entries are the target observable's	359	* observable.
357	* last valid entries. If the target changes entries, a stale event is fired	360	* <li>While invalid or stale, the wrapper's entries are the target
358	* signaling that a change is pending.	361	* observable's last valid entries. If the target changes entries, a stale
		362	* event is fired signaling that a change is pending.
359	* <li>When status changes from invalid to valid, the wrapper takes the	363	* <li>When status changes from invalid to valid, the wrapper takes the
360	* entries of the target observable, and synchronization resumes.	364	* entries of the target observable, and synchronization resumes.
361	* </ul>	365	* </ul>