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