1 /******************************************************************************* 2 * Copyright (c) 2008, 2009 Matthew Hall and others. 3 * 4 * This program and the accompanying materials 5 * are made available under the terms of the Eclipse Public License 2.0 6 * which accompanies this distribution, and is available at 7 * https://www.eclipse.org/legal/epl-2.0/ 8 * 9 * SPDX-License-Identifier: EPL-2.0 10 * 11 * Contributors: 12 * Matthew Hall - initial API and implementation (bug 219909) 13 * Matthew Hall - bug 213145 14 * Ovidio Mallo - bug 237163, 247741 15 ******************************************************************************/ 16 17 package org.eclipse.core.tests.internal.databinding.observable; 18 19 import static org.junit.Assert.assertEquals; 20 import static org.junit.Assert.assertFalse; 21 import static org.junit.Assert.assertTrue; 22 23 import org.eclipse.core.databinding.observable.Diffs; 24 import org.eclipse.core.databinding.observable.IObservable; 25 import org.eclipse.core.databinding.observable.ObservableTracker; 26 import org.eclipse.core.databinding.observable.Realm; 27 import org.eclipse.core.databinding.observable.value.IObservableValue; 28 import org.eclipse.core.databinding.observable.value.WritableValue; 29 import org.eclipse.core.internal.databinding.observable.UnmodifiableObservableValue; 30 import org.eclipse.jface.databinding.conformance.ObservableValueContractTest; 31 import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate; 32 import org.eclipse.jface.databinding.conformance.util.StaleEventTracker; 33 import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase; 34 import org.junit.Before; 35 import org.junit.Test; 36 37 import junit.framework.TestSuite; 38 39 /** 40 * @since 3.2 41 * 42 */ 43 public class UnmodifiableObservableValueTest extends 44 AbstractDefaultRealmTestCase { 45 46 private UnmodifiableObservableValueStub unmodifiable; 47 addConformanceTest(TestSuite suite)48 public static void addConformanceTest(TestSuite suite) { 49 suite.addTest(ObservableValueContractTest.suite(new Delegate())); 50 } 51 52 @Override 53 @Before setUp()54 public void setUp() throws Exception { 55 super.setUp(); 56 57 WrappedObservableValue wrapped = new WrappedObservableValue(Realm 58 .getDefault(), null, String.class); 59 unmodifiable = new UnmodifiableObservableValueStub(wrapped); 60 } 61 62 @Test testFiresStaleEvents()63 public void testFiresStaleEvents() { 64 StaleEventTracker wrappedListener = new StaleEventTracker(); 65 StaleEventTracker unmodifiableListener = new StaleEventTracker(); 66 67 unmodifiable.wrappedValue.addStaleListener(wrappedListener); 68 unmodifiable.addStaleListener(unmodifiableListener); 69 70 assertEquals(0, wrappedListener.count); 71 assertEquals(0, unmodifiableListener.count); 72 unmodifiable.wrappedValue.setStale(true); 73 assertEquals(1, wrappedListener.count); 74 assertEquals(unmodifiable.wrappedValue, wrappedListener.event 75 .getObservable()); 76 assertTrue(unmodifiable.wrappedValue.isStale()); 77 assertEquals(1, unmodifiableListener.count); 78 assertEquals(unmodifiable, unmodifiableListener.event.getObservable()); 79 assertTrue(unmodifiable.isStale()); 80 } 81 82 @Test testIsStale()83 public void testIsStale() { 84 assertFalse(unmodifiable.wrappedValue.isStale()); 85 assertFalse(unmodifiable.isStale()); 86 unmodifiable.wrappedValue.setStale(true); 87 assertTrue(unmodifiable.wrappedValue.isStale()); 88 assertTrue(unmodifiable.isStale()); 89 } 90 91 private static class Delegate extends 92 AbstractObservableValueContractDelegate { 93 private Object valueType = new Object(); 94 95 @Override createObservableValue(Realm realm)96 public IObservableValue createObservableValue(Realm realm) { 97 return new UnmodifiableObservableValueStub(new WrappedObservableValue(realm, 98 null, valueType)); 99 } 100 101 @Override getValueType(IObservableValue observable)102 public Object getValueType(IObservableValue observable) { 103 return valueType; 104 } 105 106 @Override createValue(IObservableValue observable)107 public Object createValue(IObservableValue observable) { 108 return new Object(); 109 } 110 111 @Override change(IObservable observable)112 public void change(IObservable observable) { 113 UnmodifiableObservableValueStub wrapper = (UnmodifiableObservableValueStub) observable; 114 wrapper.wrappedValue.setValue(createValue(wrapper)); 115 } 116 117 @Override setStale(IObservable observable, boolean stale)118 public void setStale(IObservable observable, boolean stale) { 119 UnmodifiableObservableValueStub wrapper = (UnmodifiableObservableValueStub) observable; 120 wrapper.wrappedValue.setStale(stale); 121 } 122 } 123 124 private static class UnmodifiableObservableValueStub extends 125 UnmodifiableObservableValue { 126 WrappedObservableValue wrappedValue; 127 UnmodifiableObservableValueStub(WrappedObservableValue wrappedValue)128 UnmodifiableObservableValueStub(WrappedObservableValue wrappedValue) { 129 super(wrappedValue); 130 this.wrappedValue = wrappedValue; 131 } 132 } 133 134 private static class WrappedObservableValue extends WritableValue { 135 private boolean stale = false; 136 WrappedObservableValue(Realm realm, Object initialValue, Object valueType)137 public WrappedObservableValue(Realm realm, Object initialValue, 138 Object valueType) { 139 super(realm, initialValue, valueType); 140 } 141 142 @Override isStale()143 public boolean isStale() { 144 ObservableTracker.getterCalled(this); 145 return stale; 146 } 147 setStale(boolean stale)148 public void setStale(boolean stale) { 149 if (this.stale != stale) { 150 this.stale = stale; 151 if (stale) { 152 fireStale(); 153 } else { 154 fireValueChange(Diffs.createValueDiff(getValue(), 155 getValue())); 156 } 157 } 158 } 159 } 160 } 161