001: /*******************************************************************************
002: * Copyright (c) 2007 IBM 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: * IBM Corporation - 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.PropertyChangeSupport;
015: import java.util.Arrays;
016:
017: import org.eclipse.core.databinding.util.ILogger;
018: import org.eclipse.core.databinding.util.Policy;
019: import org.eclipse.core.internal.databinding.internal.beans.ListenerSupport;
020: import org.eclipse.core.runtime.IStatus;
021: import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
022:
023: /**
024: * @since 1.1
025: */
026: public class ListenerSupportTest extends AbstractDefaultRealmTestCase {
027: private PropertyChangeListenerStub listener;
028: private String propertyName;
029:
030: protected void setUp() throws Exception {
031: super .setUp();
032:
033: listener = new PropertyChangeListenerStub();
034: propertyName = "value";
035: }
036:
037: public void testAddPropertyChangeListenerWithPropertyName()
038: throws Exception {
039: SpecificListenerBean bean = new SpecificListenerBean();
040:
041: ListenerSupport support = new ListenerSupport(listener,
042: propertyName);
043: assertFalse(bean.changeSupport.hasListeners(propertyName));
044: assertNull(support.getHookedTargets());
045:
046: support.hookListener(bean);
047: assertTrue("has listeners", bean.changeSupport
048: .hasListeners(propertyName));
049: assertTrue("hooked target", Arrays.asList(
050: support.getHookedTargets()).contains(bean));
051: }
052:
053: public void testAddPropertyChangeListenerWithoutPropertyName()
054: throws Exception {
055: GenericListenerBean bean = new GenericListenerBean();
056:
057: ListenerSupport support = new ListenerSupport(listener,
058: propertyName);
059: assertFalse(bean.changeSupport.hasListeners(propertyName));
060: assertNull(support.getHookedTargets());
061:
062: support.hookListener(bean);
063: assertTrue("has listeners", bean.changeSupport
064: .hasListeners(propertyName));
065: assertTrue("hooked target", Arrays.asList(
066: support.getHookedTargets()).contains(bean));
067: }
068:
069: public void testChangeListenerIsOnlyNotifiedWhenWatchedPropertyChanges()
070: throws Exception {
071: GenericListenerBean bean = new GenericListenerBean();
072: ListenerSupport support = new ListenerSupport(listener,
073: propertyName);
074: support.hookListener(bean);
075:
076: assertEquals(0, listener.count);
077: bean.setValue("1");
078: assertEquals(1, listener.count);
079: assertEquals("value", listener.event.getPropertyName());
080:
081: bean.setOther("2");
082: assertEquals(1, listener.count);
083: }
084:
085: public void testLogStatusWhenAddPropertyChangeListenerMethodIsNotFound()
086: throws Exception {
087: class BeanStub {
088: }
089:
090: class Log implements ILogger {
091: int count;
092: IStatus status;
093:
094: public void log(IStatus status) {
095: count++;
096: this .status = status;
097: }
098: }
099:
100: Log log = new Log();
101: Policy.setLog(log);
102:
103: ListenerSupport support = new ListenerSupport(listener, "value");
104: BeanStub bean = new BeanStub();
105:
106: assertEquals(0, log.count);
107: support.hookListener(bean);
108: assertEquals(1, log.count);
109: assertEquals(IStatus.WARNING, log.status.getSeverity());
110: }
111:
112: public void testRemovePropertyChangeListenerWithPropertyName()
113: throws Exception {
114: SpecificListenerBean bean = new SpecificListenerBean();
115: ListenerSupport support = new ListenerSupport(listener,
116: propertyName);
117: support.hookListener(bean);
118:
119: assertTrue(bean.changeSupport.hasListeners(propertyName));
120: assertTrue(Arrays.asList(support.getHookedTargets()).contains(
121: bean));
122:
123: support.unhookListener(bean);
124: assertFalse("has listeners", bean.changeSupport
125: .hasListeners(propertyName));
126: assertNull("unhooked target", support.getHookedTargets());
127: }
128:
129: public void testRemovePropertyChangeListenerWithoutPropertyName()
130: throws Exception {
131: GenericListenerBean bean = new GenericListenerBean();
132: ListenerSupport support = new ListenerSupport(listener,
133: propertyName);
134: support.hookListener(bean);
135:
136: assertTrue(bean.changeSupport.hasListeners(propertyName));
137: assertTrue(Arrays.asList(support.getHookedTargets()).contains(
138: bean));
139:
140: support.unhookListener(bean);
141: assertFalse("has listeners", bean.changeSupport
142: .hasListeners(propertyName));
143: assertNull("unhooked target", support.getHookedTargets());
144: }
145:
146: public void testLogStatusWhenRemovePropertyChangeListenerMethodIsNotFound()
147: throws Exception {
148: class InvalidBean {
149: }
150:
151: class Log implements ILogger {
152: int count;
153: IStatus status;
154:
155: public void log(IStatus status) {
156: count++;
157: this .status = status;
158: }
159: }
160:
161: Log log = new Log();
162: Policy.setLog(log);
163:
164: ListenerSupport support = new ListenerSupport(listener, "value");
165: InvalidBean bean = new InvalidBean();
166:
167: support.hookListener(bean);
168: log.count = 0;
169: log.status = null;
170: assertEquals(0, log.count);
171: support.unhookListener(bean);
172: assertEquals(1, log.count);
173: assertEquals(IStatus.WARNING, log.status.getSeverity());
174: }
175:
176: static class GenericListenerBean {
177: private String other;
178: PropertyChangeSupport changeSupport = new PropertyChangeSupport(
179: this );
180: private String value;
181:
182: public String getValue() {
183: return value;
184: }
185:
186: public void setValue(String value) {
187: changeSupport.firePropertyChange("value", this .value,
188: this .value = value);
189: }
190:
191: public String getOther() {
192: return other;
193: }
194:
195: public void setOther(String other) {
196: changeSupport.firePropertyChange("other", this .other,
197: this .other = other);
198: }
199:
200: public void addPropertyChangeListener(
201: PropertyChangeListener listener) {
202: changeSupport.addPropertyChangeListener(listener);
203: }
204:
205: public void removePropertyChangeListener(
206: PropertyChangeListener listener) {
207: changeSupport.removePropertyChangeListener(listener);
208: }
209: }
210:
211: static class SpecificListenerBean {
212: PropertyChangeSupport changeSupport = new PropertyChangeSupport(
213: this );
214: String propertyName;
215: String value;
216:
217: public void addPropertyChangeListener(String name,
218: PropertyChangeListener listener) {
219: this .propertyName = name;
220: changeSupport.addPropertyChangeListener(name, listener);
221: }
222:
223: public void removePropertyChangeListener(String name,
224: PropertyChangeListener listener) {
225: changeSupport.removePropertyChangeListener(name, listener);
226: }
227:
228: public String getValue() {
229: return value;
230: }
231:
232: public void setValue(String value) {
233: this .value = value;
234: }
235: }
236:
237: static class PropertyChangeListenerStub implements
238: PropertyChangeListener {
239: PropertyChangeEvent event;
240: int count;
241:
242: public void propertyChange(PropertyChangeEvent evt) {
243: count++;
244: this.event = evt;
245: }
246: }
247: }
|