001: /*******************************************************************************
002: * Copyright (c) 2007 Brad Reynolds and others.
003: * All rights reserved. This program and the accompanying materials
004: * are made available under the terms of the Eclipse Public License v1.0
005: * which accompanies this distribution, and is available at
006: * http://www.eclipse.org/legal/epl-v10.html
007: *
008: * Contributors:
009: * Brad Reynolds - initial API and implementation
010: ******************************************************************************/package org.eclipse.jface.conformance.databinding;
011:
012: import org.eclipse.core.databinding.observable.IObservable;
013: import org.eclipse.core.databinding.observable.IStaleListener;
014: import org.eclipse.core.databinding.observable.StaleEvent;
015:
016: /**
017: * @since 3.3
018: */
019: public class ObservableStaleContractTest extends ObservableDelegateTest {
020: private IObservableContractDelegate delegate;
021: private IObservable observable;
022:
023: public ObservableStaleContractTest(
024: IObservableContractDelegate delegate) {
025: this (null, delegate);
026: }
027:
028: public ObservableStaleContractTest(String testName,
029: IObservableContractDelegate delegate) {
030: super (testName, delegate);
031: this .delegate = delegate;
032: }
033:
034: protected void setUp() throws Exception {
035: super .setUp();
036:
037: observable = getObservable();
038: }
039:
040: public void testIsStale_TrueWhenStale() throws Exception {
041: delegate.setStale(observable, true);
042: assertTrue(
043: formatFail("When stale isStale() should return true."),
044: observable.isStale());
045: }
046:
047: public void testIsStale_FalseWhenNotStale() throws Exception {
048: delegate.setStale(observable, false);
049: assertFalse(
050: formatFail("When not stale isStale() should return false."),
051: observable.isStale());
052: }
053:
054: public void testBecomingStaleFiresStaleEvent() throws Exception {
055: StaleListener listener = new StaleListener();
056:
057: // precondition
058: ensureStale(observable, false);
059:
060: observable.addStaleListener(listener);
061: delegate.setStale(observable, true);
062:
063: assertEquals(
064: formatFail("When becoming stale listeners should be notified."),
065: 1, listener.count);
066: }
067:
068: public void testStaleEventObservable() throws Exception {
069: StaleListener listener = new StaleListener();
070:
071: // precondition
072: ensureStale(observable, false);
073:
074: observable.addStaleListener(listener);
075: delegate.setStale(observable, true);
076:
077: StaleEvent event = listener.event;
078: assertNotNull(formatFail("stale event was null"), event);
079: assertEquals(
080: formatFail("When notifying listeners of becoming stale the observable should be the source of the event."),
081: observable, event.getObservable());
082: }
083:
084: public void testRemoveStaleListener_RemovesListener()
085: throws Exception {
086: StaleListener listener = new StaleListener();
087:
088: observable.addStaleListener(listener);
089: ensureStale(observable, false);
090: delegate.setStale(observable, true);
091:
092: // precondition check
093: assertEquals(formatFail("set stale did not notify listeners"),
094: 1, listener.count);
095:
096: observable.removeStaleListener(listener);
097: ensureStale(observable, false);
098: delegate.setStale(observable, true);
099:
100: assertEquals(
101: formatFail("Once removed stale listeners should not be notified of becoming stale."),
102: 1, listener.count);
103: }
104:
105: public void testStaleListenersAreNotNotifiedWhenObservableIsNoLongerStale()
106: throws Exception {
107: ensureStale(observable, true);
108:
109: StaleListener listener = new StaleListener();
110: observable.addStaleListener(listener);
111: delegate.setStale(observable, false);
112:
113: assertEquals(
114: formatFail("Stale listeners should not be notified when the stale state changes from true to false."),
115: 0, listener.count);
116: }
117:
118: public void testObservableRealmIsCurrentOnStale() throws Exception {
119: ensureStale(observable, false);
120:
121: StaleListener listener = new StaleListener();
122: observable.addStaleListener(listener);
123: delegate.setStale(observable, true);
124:
125: assertTrue(
126: formatFail("When notifying listeners of becoming stale the observable's realm should be the current realm."),
127: listener.isCurrentRealm);
128: }
129:
130: /**
131: * Ensures that stale is set to the provided state. Will throw an
132: * AssertionFailedError if setting of the state is unsuccessful.
133: *
134: * @param observable
135: * @param stale
136: */
137: private void ensureStale(IObservable observable, boolean stale) {
138: if (observable.isStale() != stale) {
139: delegate.setStale(observable, stale);
140: }
141:
142: assertEquals(stale, observable.isStale());
143: }
144:
145: /* package */static class StaleListener implements IStaleListener {
146: int count;
147:
148: StaleEvent event;
149:
150: boolean isCurrentRealm;
151:
152: public void handleStale(StaleEvent staleEvent) {
153: count++;
154: this.event = staleEvent;
155: this.isCurrentRealm = staleEvent.getObservable().getRealm()
156: .isCurrent();
157: }
158: }
159:
160: }
|