001: /*******************************************************************************
002: * Copyright (c) 2006 Cerner Corporation 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.core.tests.internal.databinding.observable;
011:
012: import java.util.ArrayList;
013: import java.util.List;
014:
015: import org.eclipse.core.databinding.observable.ChangeEvent;
016: import org.eclipse.core.databinding.observable.Diffs;
017: import org.eclipse.core.databinding.observable.IChangeListener;
018: import org.eclipse.core.databinding.observable.IObservable;
019: import org.eclipse.core.databinding.observable.IStaleListener;
020: import org.eclipse.core.databinding.observable.Observables;
021: import org.eclipse.core.databinding.observable.StaleEvent;
022: import org.eclipse.core.databinding.observable.list.IListChangeListener;
023: import org.eclipse.core.databinding.observable.list.IObservableList;
024: import org.eclipse.core.databinding.observable.list.ListChangeEvent;
025: import org.eclipse.core.databinding.observable.list.ListDiff;
026: import org.eclipse.core.databinding.observable.list.ListDiffEntry;
027: import org.eclipse.core.databinding.observable.list.ObservableList;
028: import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
029:
030: public class UnmodifiableObservableListTest extends
031: AbstractDefaultRealmTestCase {
032: ObservableList unmodifiable;
033: ObservableList mutable;
034:
035: protected void setUp() throws Exception {
036: super .setUp();
037:
038: List list = new ArrayList();
039: list.add("1");
040: list.add("2");
041:
042: mutable = new MutableObservableList(list, String.class);
043: unmodifiable = (ObservableList) Observables
044: .unmodifiableObservableList(mutable);
045: }
046:
047: public void testFiresChangeEvents() throws Exception {
048: ChangeCounter mutableListener = new ChangeCounter();
049: ChangeCounter unmodifiableListener = new ChangeCounter();
050:
051: mutable.addChangeListener(mutableListener);
052: unmodifiable.addChangeListener(unmodifiableListener);
053:
054: assertEquals(0, mutableListener.count);
055: assertEquals(0, unmodifiableListener.count);
056: mutable.add("3");
057: assertEquals(1, mutableListener.count);
058: assertEquals(1, unmodifiableListener.count);
059: }
060:
061: public void testFiresListChangeEvents() throws Exception {
062: ListChangeCounter mutableListener = new ListChangeCounter();
063: ListChangeCounter unmodifiableListener = new ListChangeCounter();
064:
065: mutable.addListChangeListener(mutableListener);
066: unmodifiable.addListChangeListener(unmodifiableListener);
067:
068: assertEquals(0, mutableListener.count);
069: assertEquals(0, unmodifiableListener.count);
070:
071: String element = "3";
072: mutable.add(element);
073: assertEquals(1, mutableListener.count);
074: assertEquals(mutable, mutableListener.source);
075: assertEquals(1, mutableListener.diff.getDifferences().length);
076:
077: ListDiffEntry difference = mutableListener.diff
078: .getDifferences()[0];
079: assertEquals(element, difference.getElement());
080: assertTrue(difference.isAddition());
081: assertEquals(3, mutable.size());
082:
083: assertEquals(1, unmodifiableListener.count);
084: assertEquals(unmodifiable, unmodifiableListener.source);
085: assertEquals(1,
086: unmodifiableListener.diff.getDifferences().length);
087:
088: difference = unmodifiableListener.diff.getDifferences()[0];
089: assertEquals(element, difference.getElement());
090: assertTrue(difference.isAddition());
091: assertEquals(3, unmodifiable.size());
092: }
093:
094: public void testFiresStaleEvents() throws Exception {
095: StaleCounter mutableListener = new StaleCounter();
096: StaleCounter unmodifiableListener = new StaleCounter();
097:
098: mutable.addStaleListener(mutableListener);
099: unmodifiable.addStaleListener(unmodifiableListener);
100:
101: assertEquals(0, mutableListener.count);
102: assertEquals(0, unmodifiableListener.count);
103: mutable.setStale(true);
104: assertEquals(1, mutableListener.count);
105: assertEquals(mutable, mutableListener.source);
106: assertTrue(mutable.isStale());
107: assertEquals(1, unmodifiableListener.count);
108: assertEquals(unmodifiable, unmodifiableListener.source);
109: assertTrue(unmodifiable.isStale());
110: }
111:
112: public void testIsStale() throws Exception {
113: assertFalse(mutable.isStale());
114: assertFalse(unmodifiable.isStale());
115: mutable.setStale(true);
116: assertTrue(mutable.isStale());
117: assertTrue(unmodifiable.isStale());
118: }
119:
120: public void testSetStaleOnUnmodifiableList() throws Exception {
121: try {
122: unmodifiable.setStale(true);
123: fail("UnsupportedOperationException should have been thrown");
124: } catch (UnsupportedOperationException e) {
125: }
126: }
127:
128: private static class StaleCounter implements IStaleListener {
129: int count;
130: IObservable source;
131:
132: public void handleStale(StaleEvent event) {
133: count++;
134: this .source = event.getObservable();
135: }
136: }
137:
138: private static class ChangeCounter implements IChangeListener {
139: int count;
140: IObservable source;
141:
142: public void handleChange(ChangeEvent event) {
143: count++;
144: this .source = event.getObservable();
145: }
146: }
147:
148: private static class ListChangeCounter implements
149: IListChangeListener {
150: int count;
151: IObservableList source;
152: ListDiff diff;
153:
154: public void handleListChange(ListChangeEvent event) {
155: count++;
156: this .source = event.getObservableList();
157: this .diff = event.diff;
158: }
159: }
160:
161: private static class MutableObservableList extends ObservableList {
162: /**
163: * @param wrappedList
164: * @param elementType
165: */
166: public MutableObservableList(List wrappedList,
167: Object elementType) {
168: super (wrappedList, elementType);
169: }
170:
171: /* (non-Javadoc)
172: * @see org.eclipse.jface.internal.databinding.provisional.observable.list.ObservableList#add(java.lang.Object)
173: */
174: public boolean add(Object o) {
175: boolean result = wrappedList.add(o);
176: fireListChange(Diffs.createListDiff(Diffs
177: .createListDiffEntry(wrappedList.size() - 1, true,
178: o)));
179:
180: return result;
181: }
182: }
183: }
|