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.core.tests.internal.databinding.internal.beans;
011:
012: import java.beans.PropertyChangeEvent;
013: import java.beans.PropertyChangeListener;
014: import java.beans.PropertyDescriptor;
015: import java.util.ArrayList;
016: import java.util.Arrays;
017: import java.util.Collection;
018: import java.util.List;
019:
020: import org.eclipse.core.databinding.observable.list.ListChangeEvent;
021: import org.eclipse.core.databinding.observable.list.ListDiffEntry;
022: import org.eclipse.core.internal.databinding.internal.beans.JavaBeanObservableList;
023: import org.eclipse.jface.databinding.swt.SWTObservables;
024: import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
025: import org.eclipse.jface.tests.databinding.EventTrackers.ListChangeEventTracker;
026: import org.eclipse.swt.widgets.Display;
027:
028: /**
029: * @since 1.1
030: */
031: public class JavaBeanObservableListTest extends
032: AbstractDefaultRealmTestCase {
033: private JavaBeanObservableList list;
034:
035: private PropertyDescriptor propertyDescriptor;
036:
037: private NonStandardBean bean;
038:
039: private String propertyName;
040:
041: /*
042: * (non-Javadoc)
043: *
044: * @see junit.framework.TestCase#setUp()
045: */
046: protected void setUp() throws Exception {
047: super .setUp();
048:
049: propertyName = "list";
050: propertyDescriptor = new PropertyDescriptor(propertyName,
051: NonStandardBean.class);
052: bean = new NonStandardBean(new ArrayList());
053:
054: list = new JavaBeanObservableList(SWTObservables
055: .getRealm(Display.getDefault()), bean,
056: propertyDescriptor, NonStandardBean.class);
057: }
058:
059: public void testGetObserved() throws Exception {
060: assertEquals(bean, list.getObserved());
061: }
062:
063: public void testGetPropertyDescriptor() throws Exception {
064: assertEquals(propertyDescriptor, list.getPropertyDescriptor());
065: }
066:
067: public void testRegistersListenerAfterFirstListenerIsAdded()
068: throws Exception {
069: assertFalse(bean.changeSupport.hasListeners(propertyName));
070: list.addListChangeListener(new ListChangeEventTracker());
071: assertTrue(bean.changeSupport.hasListeners(propertyName));
072: }
073:
074: public void testRemovesListenerAfterLastListenerIsRemoved()
075: throws Exception {
076: ListChangeEventTracker listener = new ListChangeEventTracker();
077: list.addListChangeListener(listener);
078:
079: assertTrue(bean.changeSupport.hasListeners(propertyName));
080: list.removeListChangeListener(listener);
081: assertFalse(bean.changeSupport.hasListeners(propertyName));
082: }
083:
084: public void testFiresListChangeEvents() throws Exception {
085: ListChangeEventTracker listener = new ListChangeEventTracker();
086: list.addListChangeListener(listener);
087:
088: assertEquals(0, listener.count);
089: bean.setList(Arrays.asList(new String[] { "value" }));
090: assertEquals(1, listener.count);
091: }
092:
093: public void testAddAddsElement() throws Exception {
094: int count = list.size();
095: String element = "1";
096:
097: assertEquals(0, count);
098: list.add(element);
099: assertEquals(count + 1, list.size());
100: assertEquals(element, bean.getList().get(count));
101: }
102:
103: public void testAddListChangeEvent() throws Exception {
104: ListChangeEventTracker listener = new ListChangeEventTracker();
105: list.addListChangeListener(listener);
106:
107: assertEquals(0, listener.count);
108: String element = "1";
109:
110: list.add(element);
111:
112: assertEquals(1, listener.count);
113: ListChangeEvent event = listener.event;
114:
115: assertEquals(list, event.getObservableList());
116: assertEntry(event.diff.getDifferences()[0], true, 0, element);
117: }
118:
119: public void testAddFiresPropertyChangeEvent() throws Exception {
120: assertPropertyChangeEvent(bean, new Runnable() {
121: public void run() {
122: list.add("0");
123: }
124: });
125: }
126:
127: public void testAddAtIndex() throws Exception {
128: String element = "1";
129: assertEquals(0, list.size());
130:
131: list.add(0, element);
132: assertEquals(element, bean.getList().get(0));
133: }
134:
135: public void testAddAtIndexListChangeEvent() throws Exception {
136: String element = "1";
137: assertEquals(0, list.size());
138:
139: ListChangeEventTracker listener = new ListChangeEventTracker();
140: list.addListChangeListener(listener);
141:
142: list.add(0, element);
143:
144: ListChangeEvent event = listener.event;
145: assertEntry(event.diff.getDifferences()[0], true, 0, element);
146: }
147:
148: public void testAddAtIndexPropertyChangeEvent() throws Exception {
149: assertPropertyChangeEvent(bean, new Runnable() {
150: public void run() {
151: list.add(0, "0");
152: }
153: });
154: }
155:
156: public void testRemove() throws Exception {
157: String element = "1";
158: list.add(element);
159:
160: assertEquals(1, bean.getList().size());
161: list.remove(element);
162: assertEquals(0, bean.getList().size());
163: }
164:
165: public void testRemoveListChangeEvent() throws Exception {
166: String element = "1";
167: list.add(element);
168:
169: assertEquals(1, list.size());
170: ListChangeEventTracker listener = new ListChangeEventTracker();
171: list.addListChangeListener(listener);
172:
173: list.remove(element);
174:
175: assertEquals(1, listener.count);
176: ListChangeEvent event = listener.event;
177: assertEquals(list, event.getObservableList());
178: assertEntry(event.diff.getDifferences()[0], false, 0, element);
179: }
180:
181: public void testRemovePropertyChangeEvent() throws Exception {
182: list.add("0");
183:
184: assertPropertyChangeEvent(bean, new Runnable() {
185: public void run() {
186: list.remove("0");
187: }
188: });
189: }
190:
191: public void testRemoveAtIndex() throws Exception {
192: String element = "1";
193: list.add(element);
194:
195: assertEquals(element, bean.getList().get(0));
196:
197: list.remove(0);
198: assertEquals(0, bean.getList().size());
199: }
200:
201: public void testRemoveAtIndexListChangeEvent() throws Exception {
202: String element = "1";
203: list.add(element);
204:
205: assertEquals(1, list.size());
206: ListChangeEventTracker listener = new ListChangeEventTracker();
207: list.addListChangeListener(listener);
208:
209: list.remove(0);
210:
211: assertEquals(1, listener.count);
212: ListChangeEvent event = listener.event;
213: assertEquals(list, event.getObservableList());
214: assertEntry(event.diff.getDifferences()[0], false, 0, element);
215: }
216:
217: public void testRemoveAtIndexPropertyChangeEvent() throws Exception {
218: list.add("0");
219: assertPropertyChangeEvent(bean, new Runnable() {
220: public void run() {
221: list.remove(0);
222: }
223: });
224: }
225:
226: public void testAddAll() throws Exception {
227: Collection elements = Arrays.asList(new String[] { "1", "2" });
228: assertEquals(0, list.size());
229:
230: list.addAll(elements);
231:
232: assertEquals(2, bean.getList().size());
233: }
234:
235: public void testAddAllListChangEvent() throws Exception {
236: List elements = Arrays.asList(new String[] { "1", "2" });
237: assertEquals(0, list.size());
238:
239: ListChangeEventTracker listener = new ListChangeEventTracker();
240: list.addListChangeListener(listener);
241: assertEquals(0, listener.count);
242:
243: list.addAll(elements);
244:
245: assertEquals(1, listener.count);
246: ListChangeEvent event = listener.event;
247: assertEquals(list, event.getObservableList());
248:
249: assertEntry(event.diff.getDifferences()[0], true, 0, elements
250: .get(0));
251: assertEntry(event.diff.getDifferences()[1], true, 1, elements
252: .get(1));
253: }
254:
255: public void testAddAllPropertyChangeEvent() throws Exception {
256: assertPropertyChangeEvent(bean, new Runnable() {
257: public void run() {
258: list.addAll(Arrays.asList(new String[] { "0", "1" }));
259: }
260: });
261: }
262:
263: public void testAddAllAtIndex() throws Exception {
264: List elements = Arrays.asList(new String[] { "1", "2" });
265: list.addAll(elements);
266:
267: assertEquals(2, list.size());
268:
269: list.addAll(2, elements);
270:
271: assertEquals(4, bean.getList().size());
272: assertEquals(elements.get(0), bean.getList().get(0));
273: assertEquals(elements.get(1), bean.getList().get(1));
274: }
275:
276: public void testAddAllAtIndexListChangeEvent() throws Exception {
277: List elements = Arrays.asList(new String[] { "1", "2" });
278: list.addAll(elements);
279:
280: ListChangeEventTracker listener = new ListChangeEventTracker();
281: list.addListChangeListener(listener);
282:
283: assertEquals(0, listener.count);
284:
285: list.addAll(2, elements);
286:
287: assertEquals(1, listener.count);
288: ListChangeEvent event = listener.event;
289: assertEquals(list, event.getObservableList());
290: assertEntry(event.diff.getDifferences()[0], true, 2, elements
291: .get(0));
292: assertEntry(event.diff.getDifferences()[1], true, 3, elements
293: .get(1));
294: }
295:
296: public void testAddAllAtIndexPropertyChangeEvent() throws Exception {
297: assertPropertyChangeEvent(bean, new Runnable() {
298: public void run() {
299: list
300: .addAll(0, Arrays.asList(new String[] { "1",
301: "2" }));
302: }
303: });
304: }
305:
306: public void testRemoveAll() throws Exception {
307: List elements = Arrays.asList(new String[] { "1", "2" });
308: list.addAll(elements);
309: list.addAll(elements);
310:
311: assertEquals(4, bean.getList().size());
312: list.removeAll(elements);
313:
314: assertEquals(2, bean.getList().size());
315: assertEquals(elements.get(0), bean.getList().get(0));
316: assertEquals(elements.get(1), bean.getList().get(1));
317: }
318:
319: public void testRemoveAllListChangeEvent() throws Exception {
320: List elements = Arrays.asList(new String[] { "1", "2" });
321: list.addAll(elements);
322: list.addAll(elements);
323:
324: ListChangeEventTracker listener = new ListChangeEventTracker();
325: list.addListChangeListener(listener);
326:
327: assertEquals(0, listener.count);
328: list.removeAll(elements);
329:
330: ListChangeEvent event = listener.event;
331: assertEquals(list, event.getObservableList());
332: assertEntry(event.diff.getDifferences()[0], false, 0, elements
333: .get(0));
334: assertEntry(event.diff.getDifferences()[1], false, 0, elements
335: .get(1));
336: }
337:
338: public void testRemoveAllPropertyChangeEvent() throws Exception {
339: list.add("0");
340: assertPropertyChangeEvent(bean, new Runnable() {
341: public void run() {
342: list.removeAll(Arrays.asList(new String[] { "0" }));
343: }
344: });
345: }
346:
347: public void testRetailAll() throws Exception {
348: List elements = Arrays
349: .asList(new String[] { "0", "1", "2", "3" });
350: list.addAll(elements);
351:
352: assertEquals(4, bean.getList().size());
353:
354: list.retainAll(elements.subList(0, 2));
355: assertEquals(2, bean.getList().size());
356:
357: assertEquals(elements.get(0), bean.getList().get(0));
358: assertEquals(elements.get(1), bean.getList().get(1));
359: }
360:
361: public void testRetainAllListChangeEvent() throws Exception {
362: List elements = Arrays
363: .asList(new String[] { "0", "1", "2", "3" });
364: list.addAll(elements);
365:
366: ListChangeEventTracker listener = new ListChangeEventTracker();
367: list.addListChangeListener(listener);
368:
369: assertEquals(0, listener.count);
370: list.retainAll(elements.subList(0, 2));
371:
372: assertEquals(1, listener.count);
373: ListChangeEvent event = listener.event;
374: assertEquals(list, event.getObservableList());
375: assertEntry(event.diff.getDifferences()[0], false, 2, elements
376: .get(2));
377: assertEntry(event.diff.getDifferences()[1], false, 2, elements
378: .get(3));
379: }
380:
381: public void testRetainAllPropertyChangeEvent() throws Exception {
382: list.addAll(Arrays.asList(new String[] { "0", "1" }));
383:
384: assertPropertyChangeEvent(bean, new Runnable() {
385: public void run() {
386: list.retainAll(Arrays.asList(new String[] { "0" }));
387: }
388: });
389: }
390:
391: public void testSet() throws Exception {
392: String oldElement = "old";
393: String newElement = "new";
394: list.add(oldElement);
395:
396: assertEquals(oldElement, bean.getList().get(0));
397:
398: list.set(0, newElement);
399: assertEquals(newElement, bean.getList().get(0));
400: }
401:
402: public void testSetListChangeEvent() throws Exception {
403: String oldElement = "old";
404: String newElement = "new";
405: list.add(oldElement);
406:
407: ListChangeEventTracker listener = new ListChangeEventTracker();
408: list.addListChangeListener(listener);
409: assertEquals(0, listener.count);
410:
411: list.set(0, newElement);
412:
413: assertEquals(1, listener.count);
414: ListChangeEvent event = listener.event;
415: assertEquals(list, event.getObservableList());
416: assertEntry(event.diff.getDifferences()[0], true, 0, newElement);
417: assertEntry(event.diff.getDifferences()[1], false, 1,
418: oldElement);
419: }
420:
421: public void testSetPropertyChangeEvent() throws Exception {
422: list.add("0");
423: assertPropertyChangeEvent(bean, new Runnable() {
424: public void run() {
425: list.set(0, "1");
426: }
427: });
428: }
429:
430: public void testListChangeEventFiresWhenNewListIsSet()
431: throws Exception {
432: List elements = Arrays.asList(new String[] { "1", "2" });
433:
434: ListChangeEventTracker listener = new ListChangeEventTracker();
435: list.addListChangeListener(listener);
436:
437: assertEquals(0, listener.count);
438: bean.setList(elements);
439: assertEquals(1, listener.count);
440: }
441:
442: private static void assertEntry(ListDiffEntry entry,
443: boolean addition, int position, Object element) {
444: assertEquals("addition", addition, entry.isAddition());
445: assertEquals("position", position, entry.getPosition());
446: assertEquals("element", element, entry.getElement());
447: }
448:
449: private static void assertPropertyChangeEvent(NonStandardBean bean,
450: Runnable runnable) {
451: PropertyChangeTracker listener = new PropertyChangeTracker();
452: bean.addPropertyChangeListener(listener);
453:
454: List old = bean.getList();
455: assertEquals(0, listener.count);
456:
457: runnable.run();
458:
459: PropertyChangeEvent event = listener.evt;
460: assertEquals("event did not fire", 1, listener.count);
461: assertEquals("list", event.getPropertyName());
462: assertEquals("old value", old, event.getOldValue());
463: assertEquals("new value", bean.getList(), event.getNewValue());
464: assertFalse("lists are equal", bean.getList().equals(old));
465: }
466:
467: private static class PropertyChangeTracker implements
468: PropertyChangeListener {
469: int count;
470:
471: PropertyChangeEvent evt;
472:
473: /*
474: * (non-Javadoc)
475: *
476: * @see java.beans.PropertyChangeListener#propertyChange(java.beans.PropertyChangeEvent)
477: */
478: public void propertyChange(PropertyChangeEvent evt) {
479: count++;
480: this.evt = evt;
481: }
482: }
483: }
|