### Eclipse Workspace Patch 1.0 #P org.eclipse.jface.tests.databinding Index: src/org/eclipse/core/tests/internal/databinding/observable/ValidatedObservableValueTest.java =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/core/tests/internal/databinding/observable/ValidatedObservableValueTest.java,v retrieving revision 1.1 diff -u -r1.1 ValidatedObservableValueTest.java --- src/org/eclipse/core/tests/internal/databinding/observable/ValidatedObservableValueTest.java 24 Mar 2008 22:55:55 -0000 1.1 +++ src/org/eclipse/core/tests/internal/databinding/observable/ValidatedObservableValueTest.java 28 Sep 2008 15:57:08 -0000 @@ -7,6 +7,7 @@ * * Contributors: * Matthew Hall - initial API and implementation (bug 218269) + * Ovidio Mallo - bug 248868 ******************************************************************************/ package org.eclipse.core.tests.internal.databinding.observable; @@ -16,6 +17,7 @@ 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; @@ -26,6 +28,7 @@ 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; @@ -36,7 +39,7 @@ public class ValidatedObservableValueTest extends AbstractDefaultRealmTestCase { private ValidatedObservableValue validated; private ObservableValueStub target; - private IObservableValue validationStatus; + private ValidationObservableValue validationStatus; private Object oldValue; private Object newValue; @@ -47,8 +50,7 @@ newValue = new Object(); target = new ObservableValueStub(Realm.getDefault()); target.setValue(oldValue); - validationStatus = new WritableValue(ValidationStatus.ok(), - IStatus.class); + validationStatus = new ValidationObservableValue(); validated = new ValidatedObservableValue(target, validationStatus); } @@ -56,7 +58,7 @@ CurrentRealm realm1 = new CurrentRealm(true); CurrentRealm realm2 = new CurrentRealm(true); target = new ObservableValueStub(realm1); - validationStatus = new WritableValue(realm2); + validationStatus = new ValidationObservableValue(realm2); try { new ValidatedObservableValue(target, validationStatus); fail("Expected exception--target and validation status should have the same realm"); @@ -65,16 +67,39 @@ } 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()); @@ -84,15 +109,92 @@ // 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() { @@ -212,10 +314,17 @@ 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 { @@ -302,4 +411,32 @@ } } + 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())); + } + } + } + } } \ No newline at end of file Index: src/org/eclipse/core/tests/internal/databinding/observable/ValidatedObservableSetTest.java =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/core/tests/internal/databinding/observable/ValidatedObservableSetTest.java,v retrieving revision 1.1 diff -u -r1.1 ValidatedObservableSetTest.java --- src/org/eclipse/core/tests/internal/databinding/observable/ValidatedObservableSetTest.java 24 Mar 2008 22:55:55 -0000 1.1 +++ src/org/eclipse/core/tests/internal/databinding/observable/ValidatedObservableSetTest.java 28 Sep 2008 15:57:08 -0000 @@ -7,6 +7,7 @@ * * Contributors: * Matthew Hall - initial API and implementation (bug 218269) + * Ovidio Mallo - bug 248868 ******************************************************************************/ package org.eclipse.core.tests.internal.databinding.observable; @@ -14,9 +15,12 @@ import java.util.Collections; import junit.framework.Test; +import junit.framework.TestSuite; +import org.eclipse.core.databinding.observable.Diffs; import org.eclipse.core.databinding.observable.IObservable; import org.eclipse.core.databinding.observable.IObservableCollection; +import org.eclipse.core.databinding.observable.ObservableTracker; import org.eclipse.core.databinding.observable.Realm; import org.eclipse.core.databinding.observable.set.IObservableSet; import org.eclipse.core.databinding.observable.set.WritableSet; @@ -27,11 +31,100 @@ import org.eclipse.core.runtime.IStatus; import org.eclipse.jface.databinding.conformance.MutableObservableSetContractTest; import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableCollectionContractDelegate; +import org.eclipse.jface.databinding.conformance.util.SetChangeEventTracker; +import org.eclipse.jface.databinding.conformance.util.StaleEventTracker; import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase; public class ValidatedObservableSetTest extends AbstractDefaultRealmTestCase { + private ValidatedObservableSet validated; + private IObservableSet target; + private ValidationObservableValue validationStatus; + + protected void setUp() throws Exception { + super.setUp(); + + target = new WritableSet(); + validationStatus = new ValidationObservableValue(); + validated = new ValidatedObservableSet(target, validationStatus); + } + + public void testIsStale_WhenStatusIsStale() { + SetChangeEventTracker validatedChangeTracker = SetChangeEventTracker + .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() { + SetChangeEventTracker validatedChangeTracker = SetChangeEventTracker + .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.add(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.add(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() { - return MutableObservableSetContractTest.suite(new Delegate()); + TestSuite suite = new TestSuite(ValidatedObservableSetTest.class + .getName()); + suite.addTestSuite(ValidatedObservableSetTest.class); + suite.addTest(MutableObservableSetContractTest.suite(new Delegate())); + return suite; } static class Delegate extends AbstractObservableCollectionContractDelegate { @@ -85,4 +178,29 @@ this.validationStatus = validationStatus; } } + + 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())); + } + } + } + } } Index: src/org/eclipse/core/tests/internal/databinding/observable/ValidatedObservableListTest.java =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.jface.tests.databinding/src/org/eclipse/core/tests/internal/databinding/observable/ValidatedObservableListTest.java,v retrieving revision 1.1 diff -u -r1.1 ValidatedObservableListTest.java --- src/org/eclipse/core/tests/internal/databinding/observable/ValidatedObservableListTest.java 24 Mar 2008 22:55:55 -0000 1.1 +++ src/org/eclipse/core/tests/internal/databinding/observable/ValidatedObservableListTest.java 28 Sep 2008 15:57:08 -0000 @@ -7,6 +7,7 @@ * * Contributors: * Matthew Hall - initial API and implementation (bug 218269) + * Ovidio Mallo - bug 248868 ******************************************************************************/ package org.eclipse.core.tests.internal.databinding.observable; @@ -14,9 +15,12 @@ import java.util.ArrayList; import junit.framework.Test; +import junit.framework.TestSuite; +import org.eclipse.core.databinding.observable.Diffs; import org.eclipse.core.databinding.observable.IObservable; import org.eclipse.core.databinding.observable.IObservableCollection; +import org.eclipse.core.databinding.observable.ObservableTracker; import org.eclipse.core.databinding.observable.Realm; import org.eclipse.core.databinding.observable.list.IObservableList; import org.eclipse.core.databinding.observable.list.WritableList; @@ -27,11 +31,99 @@ import org.eclipse.core.runtime.IStatus; import org.eclipse.jface.databinding.conformance.MutableObservableListContractTest; import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableCollectionContractDelegate; +import org.eclipse.jface.databinding.conformance.util.ListChangeEventTracker; +import org.eclipse.jface.databinding.conformance.util.StaleEventTracker; import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase; public class ValidatedObservableListTest extends AbstractDefaultRealmTestCase { + private ValidatedObservableList validated; + private IObservableList target; + private ValidationObservableValue validationStatus; + + protected void setUp() throws Exception { + super.setUp(); + + target = new WritableList(); + validationStatus = new ValidationObservableValue(); + validated = new ValidatedObservableList(target, validationStatus); + } + + public void testIsStale_WhenStatusIsStale() { + ListChangeEventTracker validatedChangeTracker = ListChangeEventTracker + .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() { + ListChangeEventTracker validatedChangeTracker = ListChangeEventTracker + .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.add(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.add(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() { - return MutableObservableListContractTest.suite(new Delegate()); + TestSuite suite = new TestSuite(ValidatedObservableListTest.class.getName()); + suite.addTestSuite(ValidatedObservableListTest.class); + suite.addTest(MutableObservableListContractTest.suite(new Delegate())); + return suite; } static class Delegate extends AbstractObservableCollectionContractDelegate { @@ -85,4 +177,29 @@ this.validationStatus = validationStatus; } } + + 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())); + } + } + } + } } Index: src/org/eclipse/core/tests/internal/databinding/observable/ValidatedObservableMapTest.java =================================================================== RCS file: src/org/eclipse/core/tests/internal/databinding/observable/ValidatedObservableMapTest.java diff -N src/org/eclipse/core/tests/internal/databinding/observable/ValidatedObservableMapTest.java --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ src/org/eclipse/core/tests/internal/databinding/observable/ValidatedObservableMapTest.java 1 Jan 1970 00:00:00 -0000 @@ -0,0 +1,144 @@ +/******************************************************************************* + * 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())); + } + } + } + } +} #P org.eclipse.core.databinding Index: src/org/eclipse/core/databinding/validation/MultiValidator.java =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.core.databinding/src/org/eclipse/core/databinding/validation/MultiValidator.java,v retrieving revision 1.4 diff -u -r1.4 MultiValidator.java --- src/org/eclipse/core/databinding/validation/MultiValidator.java 31 Jul 2008 20:17:08 -0000 1.4 +++ src/org/eclipse/core/databinding/validation/MultiValidator.java 28 Sep 2008 15:57:10 -0000 @@ -9,7 +9,7 @@ * Matthew Hall - initial API and implementation (bug 218269) * Boris Bokowski - bug 218269 * Matthew Hall - bug 237884, 240590 - * Ovidio Mallo - bug 238909 + * Ovidio Mallo - bugs 238909, 248868 ******************************************************************************/ package org.eclipse.core.databinding.validation; @@ -265,16 +265,17 @@ /** * Returns a wrapper {@link IObservableValue} which stays in sync with the - * given target observable only when the validation status is valid. - * Statuses of {@link IStatus#OK OK}, {@link IStatus#INFO INFO} or + * 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. *
* The wrapper behaves as follows with respect to the validation status: *
* The wrapper behaves as follows with respect to the validation status: *
* The wrapper behaves as follows with respect to the validation status: *
* The wrapper behaves as follows with respect to the validation status: *
* Note: *