1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *     http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18package org.apache.harmony.beans.tests.java.beans;
19
20import java.beans.IndexedPropertyChangeEvent;
21import java.beans.PropertyChangeEvent;
22import java.beans.PropertyChangeListener;
23import java.beans.PropertyChangeListenerProxy;
24import java.beans.PropertyChangeSupport;
25import java.io.File;
26import java.io.FileInputStream;
27import java.io.FileOutputStream;
28import java.io.IOException;
29import java.io.ObjectInputStream;
30import java.io.ObjectOutputStream;
31import java.io.Serializable;
32
33import junit.framework.TestCase;
34
35import org.apache.harmony.beans.tests.support.NonSerializablePropertyChangeListener;
36import org.apache.harmony.beans.tests.support.SerializablePropertyChangeListener;
37import org.apache.harmony.testframework.serialization.SerializationTest;
38import org.apache.harmony.testframework.serialization.SerializationTest.SerializableAssert;
39
40import tests.util.SerializationTester;
41
42/**
43 * Test class PropertyChangeSupport.
44 */
45public class PropertyChangeSupportTest extends TestCase {
46
47    private File tempFile;
48
49    @Override
50    protected void setUp() throws Exception {
51        tempFile = File.createTempFile("beans", ".ser");
52    }
53
54    @Override
55    protected void tearDown() throws Exception {
56        tempFile.delete();
57        tempFile = null;
58    }
59    /*
60     * Test the constructor with a normal parameter.
61     */
62    public void testConstructor_Normal() {
63        Object src = new Object();
64        new PropertyChangeSupport(src);
65    }
66
67    /*
68     * Test the method addPropertyChangeListener(PropertyChangeListener) with a
69     * normal listener parameter.
70     */
71    public void testAddPropertyChangeListener_PropertyChangeListener_Normal() {
72        Object src = new Object();
73        PropertyChangeSupport sup = new PropertyChangeSupport(src);
74        PropertyChangeListener l1 = new MockPropertyChangeListener();
75        PropertyChangeListener l2 = new MockPropertyChangeListener();
76        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
77                l2);
78        PropertyChangeListener l4 = new PropertyChangeListenerProxy("myProp",
79                l3);
80
81        sup.addPropertyChangeListener(l1);
82
83        assertEquals(1, sup.getPropertyChangeListeners().length);
84        assertSame(l1, sup.getPropertyChangeListeners()[0]);
85
86        sup.removePropertyChangeListener(l1);
87        sup.addPropertyChangeListener(l3);
88        assertEquals(1, sup.getPropertyChangeListeners().length);
89        assertSame(l2, ((PropertyChangeListenerProxy) sup
90                .getPropertyChangeListeners()[0]).getListener());
91        assertNotSame(l3, sup.getPropertyChangeListeners()[0]);
92
93        sup.removePropertyChangeListener(sup.getPropertyChangeListeners()[0]);
94        assertEquals(0, sup.getPropertyChangeListeners().length);
95        sup.addPropertyChangeListener(l4);
96        //RI asserts to true here, really strange behavior
97        assertNotSame(l3, ((PropertyChangeListenerProxy) sup
98                .getPropertyChangeListeners()[0]).getListener());
99        assertNotSame(l4, sup.getPropertyChangeListeners()[0]);
100        assertSame(
101                l2,
102                ((PropertyChangeListenerProxy) ((PropertyChangeListenerProxy) sup
103                        .getPropertyChangeListeners()[0]).getListener())
104                        .getListener());
105    }
106
107    /*
108     * Test the method addPropertyChangeListener(PropertyChangeListener) with a
109     * null listener parameter.
110     */
111    public void testAddPropertyChangeListener_PropertyChangeListener_Null() {
112        Object src = new Object();
113        PropertyChangeSupport sup = new PropertyChangeSupport(src);
114
115        sup.addPropertyChangeListener(null);
116        PropertyChangeListener[] listeners = sup.getPropertyChangeListeners();
117        assertEquals(0, listeners.length);
118    }
119
120    /*
121     * Test the method addPropertyChangeListener(PropertyChangeListener) with a
122     * listener parameter that has already been registered.
123     */
124    public void testAddPropertyChangeListener_PropertyChangeListener_Duplicate() {
125        Object src = new Object();
126        PropertyChangeSupport sup = new PropertyChangeSupport(src);
127        PropertyChangeListener l1 = new MockPropertyChangeListener();
128
129        sup.addPropertyChangeListener(l1);
130        sup.addPropertyChangeListener(l1);
131
132        PropertyChangeListener[] listeners = sup.getPropertyChangeListeners();
133        assertEquals(2, listeners.length);
134        assertSame(l1, listeners[0]);
135        assertSame(l1, listeners[1]);
136    }
137
138    /*
139     * Test the method addPropertyChangeListener(PropertyChangeListener,
140     * String) with a normal listener parameter and property name parameter.
141     */
142    public void testAddPropertyChangeListener_PropertyChangeListener_String_Normal() {
143        Object src = new Object();
144        PropertyChangeSupport sup = new PropertyChangeSupport(src);
145        PropertyChangeListener l1 = new MockPropertyChangeListener();
146        PropertyChangeListener l2 = new MockPropertyChangeListener();
147        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
148                l2);
149        PropertyChangeListener[] listeners;
150
151        sup.addPropertyChangeListener("myProp2", l1);
152
153        listeners = sup.getPropertyChangeListeners();
154        assertEquals(1, listeners.length);
155        assertSame(l1, ((PropertyChangeListenerProxy) listeners[0])
156                .getListener());
157
158        sup.removePropertyChangeListener(listeners[0]);
159        sup.addPropertyChangeListener("myProp3", l3);
160        listeners = sup.getPropertyChangeListeners();
161        assertEquals(1, listeners.length);
162        // pay attention to this recursive proxy
163        assertNotSame(l3, ((PropertyChangeListenerProxy) listeners[0])
164                .getListener());
165        assertNotSame(l3, listeners[0]);
166        assertSame(
167                l2,
168                ((PropertyChangeListenerProxy) ((PropertyChangeListenerProxy) listeners[0])
169                        .getListener()).getListener());
170
171        listeners = sup.getPropertyChangeListeners("myProp");
172        assertEquals(0, listeners.length);
173
174        listeners = sup.getPropertyChangeListeners("myProp3");
175        assertEquals(1, listeners.length);
176        // pay attention to this recursive proxy
177        assertNotSame(l3, ((PropertyChangeListenerProxy) listeners[0])
178                .getListener());
179        assertNotSame(l3, listeners[0]);
180        assertSame(l2, ((PropertyChangeListenerProxy) listeners[0])
181                .getListener());
182
183    }
184
185    /*
186     * Test the method addPropertyChangeListener(PropertyChangeListener,
187     * String) with a null listener parameter and a normal property name
188     * parameter.
189     */
190    public void testAddPropertyChangeListener_PropertyChangeListener_String_NullListener() {
191        Object src = new Object();
192        PropertyChangeSupport sup = new PropertyChangeSupport(src);
193
194        sup.addPropertyChangeListener("myProp", null);
195
196        PropertyChangeListener[] listeners = sup.getPropertyChangeListeners();
197        assertEquals(0, listeners.length);
198
199        new PropertyChangeListenerProxy("myProp", null);
200        assertEquals(0, listeners.length);
201    }
202
203    /*
204     * Test the method addPropertyChangeListener(PropertyChangeListener,
205     * String) with a normal listener parameter and a null property name
206     * parameter.
207     */
208    public void testAddPropertyChangeListener_PropertyChangeListener_String_NullProperty() {
209        Object src = new Object();
210        PropertyChangeSupport sup = new PropertyChangeSupport(src);
211        PropertyChangeListener l1 = new MockPropertyChangeListener();
212        PropertyChangeListener l2 = new MockPropertyChangeListener();
213        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
214                l2);
215
216        sup.addPropertyChangeListener(null, l1);
217        sup.addPropertyChangeListener(null, l3);
218        l3 = new PropertyChangeListenerProxy(null, l2);
219        sup.addPropertyChangeListener(l3);
220    }
221
222    /*
223     * Test the method addPropertyChangeListener(PropertyChangeListener,
224     * String) with a listener parameter that has already been registered for
225     * the named property.
226     */
227    public void testAddPropertyChangeListener_PropertyChangeListener_String_Duplicate() {
228        Object src = new Object();
229        PropertyChangeSupport sup = new PropertyChangeSupport(src);
230        PropertyChangeListener l1 = new MockPropertyChangeListener();
231        PropertyChangeListener l2 = new MockPropertyChangeListener();
232        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
233                l2);
234
235        sup.addPropertyChangeListener("myProp2", l1);
236        sup.addPropertyChangeListener("myProp2", l1);
237
238        PropertyChangeListener[] listeners = sup.getPropertyChangeListeners();
239        assertEquals(2, listeners.length);
240        assertSame(l1, ((PropertyChangeListenerProxy) listeners[0])
241                .getListener());
242        assertSame(l1, ((PropertyChangeListenerProxy) listeners[1])
243                .getListener());
244
245        sup.removePropertyChangeListener(listeners[0]);
246        sup.removePropertyChangeListener(listeners[1]);
247        sup.addPropertyChangeListener("myProp3", l3);
248        sup.addPropertyChangeListener("myProp3", l3);
249        listeners = sup.getPropertyChangeListeners();
250        assertEquals(2, listeners.length);
251        assertSame(
252                l2,
253                ((PropertyChangeListenerProxy) ((PropertyChangeListenerProxy) listeners[0])
254                        .getListener()).getListener());
255        assertSame(
256                l2,
257                ((PropertyChangeListenerProxy) ((PropertyChangeListenerProxy) listeners[1])
258                        .getListener()).getListener());
259    }
260
261    /*
262     * Test the method removePropertyChangeListener(PropertyChangeListener)
263     * with a normal listener parameter.
264     */
265    public void testRemovePropertyChangeListener_PropertyChangeListener_Normal() {
266        Object src = new Object();
267        PropertyChangeSupport sup = new PropertyChangeSupport(src);
268        PropertyChangeListener l1 = new MockPropertyChangeListener();
269        PropertyChangeListener l2 = new MockPropertyChangeListener();
270        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
271                l2);
272
273        sup.addPropertyChangeListener(l1);
274
275        PropertyChangeListener[] listeners = sup.getPropertyChangeListeners();
276        assertEquals(1, listeners.length);
277        sup.removePropertyChangeListener(l1);
278        listeners = sup.getPropertyChangeListeners();
279        assertEquals(0, listeners.length);
280        sup.addPropertyChangeListener(l3);
281        listeners = sup.getPropertyChangeListeners();
282        assertEquals(1, listeners.length);
283        sup.removePropertyChangeListener(l3);
284        listeners = sup.getPropertyChangeListeners();
285        assertEquals(0, listeners.length);
286        sup.addPropertyChangeListener("myProp3", l2);
287        listeners = sup.getPropertyChangeListeners();
288        assertEquals(1, listeners.length);
289        sup.removePropertyChangeListener(l2);
290        listeners = sup.getPropertyChangeListeners();
291        assertEquals(1, listeners.length);
292        sup.removePropertyChangeListener(listeners[0]);
293        listeners = sup.getPropertyChangeListeners();
294        assertEquals(0, listeners.length);
295    }
296
297    /*
298     * Test the method removePropertyChangeListener(PropertyChangeListener)
299     * with a null listener parameter.
300     */
301    public void testRemovePropertyChangeListener_PropertyChangeListener_Null() {
302        Object src = new Object();
303        PropertyChangeSupport sup = new PropertyChangeSupport(src);
304
305        sup.removePropertyChangeListener(null);
306        assertEquals(0, sup.getPropertyChangeListeners().length);
307        sup.addPropertyChangeListener(null);
308        assertEquals(0, sup.getPropertyChangeListeners().length);
309        sup.removePropertyChangeListener(null);
310        assertEquals(0, sup.getPropertyChangeListeners().length);
311    }
312
313    /*
314     * Test the method removePropertyChangeListener(PropertyChangeListener)
315     * with a non-registered listener parameter.
316     */
317    public void testRemovePropertyChangeListener_PropertyChangeListener_NonRegistered() {
318        Object src = new Object();
319        PropertyChangeSupport sup = new PropertyChangeSupport(src);
320        sup.removePropertyChangeListener(new MockPropertyChangeListener());
321        assertEquals(0, sup.getPropertyChangeListeners().length);
322    }
323
324    /*
325     * Test the method removePropertyChangeListener(PropertyChangeListener,
326     * String) when a listener for all properties has been registered.
327     */
328    public void testRemovePropertyChangeListener_PropertyChangeListener_String_AllRegistered() {
329        Object src = new Object();
330        PropertyChangeSupport sup = new PropertyChangeSupport(src);
331        Object newValue = new Object();
332        Object oldValue = new Object();
333
334        MockPropertyChangeListener l1 = new MockPropertyChangeListener(src,
335                "myProp", oldValue, newValue);
336
337        sup.addPropertyChangeListener(l1);
338
339        sup.removePropertyChangeListener("myProp", l1);
340        assertEquals(1, sup.getPropertyChangeListeners().length);
341        assertEquals(0, sup.getPropertyChangeListeners("myProp").length);
342        sup.firePropertyChange("myProp", oldValue, newValue);
343        l1.assertCalled();
344    }
345
346    /*
347     * Test the method removePropertyChangeListener(PropertyChangeListener,
348     * String) when a listener for the named property has been registered.
349     */
350    public void testRemovePropertyChangeListener_PropertyChangeListener_String_PropertyRegistered() {
351        Object src = new Object();
352        PropertyChangeSupport sup = new PropertyChangeSupport(src);
353        PropertyChangeListener l1 = new MockPropertyChangeListener();
354        sup.addPropertyChangeListener("myProp", l1);
355        assertEquals(1, sup.getPropertyChangeListeners().length);
356
357        sup.removePropertyChangeListener("myProp", l1);
358        assertEquals(0, sup.getPropertyChangeListeners().length);
359        assertEquals(0, sup.getPropertyChangeListeners("myProp").length);
360
361        PropertyChangeListener l2 = new MockPropertyChangeListener();
362        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
363                l2);
364        sup.addPropertyChangeListener(l3);
365        assertEquals(1, sup.getPropertyChangeListeners().length);
366        sup.removePropertyChangeListener("myProp", l2);
367        assertEquals(0, sup.getPropertyChangeListeners().length);
368        assertEquals(0, sup.getPropertyChangeListeners("myProp").length);
369    }
370
371    /*
372     * Test the method removePropertyChangeListener(PropertyChangeListener,
373     * String) with a non-registered listener parameter.
374     */
375    public void testRemovePropertyChangeListener_PropertyChangeListener_String_NonRegistered() {
376        Object src = new Object();
377        PropertyChangeSupport sup = new PropertyChangeSupport(src);
378        sup.removePropertyChangeListener("myProp",
379                new MockPropertyChangeListener());
380        assertEquals(0, sup.getPropertyChangeListeners().length);
381    }
382
383    /*
384     * Test the method removePropertyChangeListener(PropertyChangeListener,
385     * String) with a null listener parameter.
386     */
387    public void testRemovePropertyChangeListener_PropertyChangeListener_String_NullListener() {
388        Object src = new Object();
389        PropertyChangeSupport sup = new PropertyChangeSupport(src);
390
391        sup.removePropertyChangeListener("myProp", null);
392        assertEquals(0, sup.getPropertyChangeListeners().length);
393        sup.addPropertyChangeListener("myProp", null);
394        assertEquals(0, sup.getPropertyChangeListeners().length);
395        sup.removePropertyChangeListener("myProp", null);
396        assertEquals(0, sup.getPropertyChangeListeners().length);
397    }
398
399    /*
400     * Test the method removePropertyChangeListener(PropertyChangeListener,
401     * String) with a null property name parameter.
402     */
403    public void testRemovePropertyChangeListener_PropertyChangeListener_String_NullProperty() {
404        Object src = new Object();
405        PropertyChangeSupport sup = new PropertyChangeSupport(src);
406
407        sup.removePropertyChangeListener(null,
408                new MockPropertyChangeListener());
409        sup.addPropertyChangeListener("myProp",
410                new MockPropertyChangeListener());
411        sup.removePropertyChangeListener(null,
412                new MockPropertyChangeListener());
413    }
414
415    /*
416     * Test the method getPropertyChangeListeners() when there is one listener
417     * for all properties and one for a named property.
418     */
419    public void testGetPropertyChangeListener_Normal() {
420        Object src = new Object();
421        PropertyChangeSupport sup = new PropertyChangeSupport(src);
422        PropertyChangeListener l1 = new MockPropertyChangeListener();
423        PropertyChangeListener l2 = new MockPropertyChangeListener();
424        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
425                l2);
426        PropertyChangeListener l4 = new MockPropertyChangeListener();
427
428        sup.addPropertyChangeListener(l1);
429        sup.addPropertyChangeListener(l3);
430        sup.addPropertyChangeListener("myProp2", l4);
431
432        assertEquals(3, sup.getPropertyChangeListeners().length);
433    }
434
435    /*
436     * Test the method getPropertyChangeListeners() when there is no listeners.
437     */
438    public void testGetPropertyChangeListener_Empty() {
439        Object src = new Object();
440        PropertyChangeSupport sup = new PropertyChangeSupport(src);
441        assertEquals(0, sup.getPropertyChangeListeners().length);
442    }
443
444    /*
445     * Test the method getPropertyChangeListeners(String) when there is one
446     * listener for all properties and one for the named property and a third
447     * for another named property.
448     */
449    public void testGetPropertyChangeListener_String_Normal() {
450        Object src = new Object();
451        PropertyChangeSupport sup = new PropertyChangeSupport(src);
452        PropertyChangeListener l1 = new MockPropertyChangeListener();
453        PropertyChangeListener l2 = new MockPropertyChangeListener();
454        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
455                l2);
456        PropertyChangeListener l4 = new MockPropertyChangeListener();
457
458        sup.addPropertyChangeListener(l1);
459        sup.addPropertyChangeListener(l3);
460        sup.addPropertyChangeListener("myProp2", l4);
461
462        assertEquals(1, sup.getPropertyChangeListeners("myProp").length);
463        assertSame(l2, sup.getPropertyChangeListeners("myProp")[0]);
464        sup.addPropertyChangeListener("myProp",
465                new MockPropertyChangeListener());
466        assertEquals(2, sup.getPropertyChangeListeners("myProp").length);
467    }
468
469    /*
470     * Test the method getPropertyChangeListeners(String) when there is no
471     * listener for the named property but there is one for another named
472     * property.
473     */
474    public void testGetPropertyChangeListener_String_None() {
475        Object src = new Object();
476        PropertyChangeSupport sup = new PropertyChangeSupport(src);
477        PropertyChangeListener l1 = new MockPropertyChangeListener();
478        PropertyChangeListener l2 = new MockPropertyChangeListener();
479        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp2",
480                l2);
481        PropertyChangeListener l4 = new MockPropertyChangeListener();
482
483        sup.addPropertyChangeListener(l1);
484        sup.addPropertyChangeListener(l3);
485        sup.addPropertyChangeListener("myProp3", l4);
486
487        assertEquals(0, sup.getPropertyChangeListeners("myProp").length);
488    }
489
490    /*
491     * Test the method getPropertyChangeListeners(String) with a null parameter.
492     */
493    public void testGetPropertyChangeListener_String_Null() {
494        Object src = new Object();
495        PropertyChangeSupport sup = new PropertyChangeSupport(src);
496
497        sup.getPropertyChangeListeners(null);
498        sup.addPropertyChangeListener("myProp",
499                new MockPropertyChangeListener());
500        sup.getPropertyChangeListeners(null);
501    }
502
503    /*
504     * Test the method hasListeners(String) when there is one listener for all
505     * properties.
506     */
507    public void testHasListener_AllRegistered() {
508        Object src = new Object();
509        PropertyChangeSupport sup = new PropertyChangeSupport(src);
510        PropertyChangeListener l1 = new MockPropertyChangeListener();
511        PropertyChangeListener l2 = new MockPropertyChangeListener();
512        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
513                l2);
514
515        assertFalse(sup.hasListeners("myProp"));
516        sup.addPropertyChangeListener(l1);
517        assertTrue(sup.hasListeners("myProp"));
518        sup.removePropertyChangeListener(l1);
519        assertFalse(sup.hasListeners("myProp"));
520        sup.addPropertyChangeListener(l3);
521        assertTrue(sup.hasListeners("myProp"));
522    }
523
524    /*
525     * Test the method hasListeners(String) when there is one listener for the
526     * named property.
527     */
528    public void testHasListener_PropertyRegistered() {
529        Object src = new Object();
530        PropertyChangeSupport sup = new PropertyChangeSupport(src);
531        PropertyChangeListener l1 = new MockPropertyChangeListener();
532        PropertyChangeListener l2 = new MockPropertyChangeListener();
533        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
534                l2);
535
536        assertFalse(sup.hasListeners("myProp"));
537        sup.addPropertyChangeListener("myProP", l1);
538        assertFalse(sup.hasListeners("myProp"));
539        sup.addPropertyChangeListener("myProp", l2);
540        assertTrue(sup.hasListeners("myProp"));
541        sup.removePropertyChangeListener("myProp", l2);
542        assertFalse(sup.hasListeners("myProp"));
543        // The following assertion fails on RI. See HARMONY-2526
544        sup.addPropertyChangeListener("myProp", l3);
545        assertTrue(sup.hasListeners("myProp"));
546    }
547
548    /*
549     * Test the method hasListeners(String) when there is no listeners.
550     */
551    public void testHasListener_None() {
552        Object src = new Object();
553        PropertyChangeSupport sup = new PropertyChangeSupport(src);
554        assertFalse(sup.hasListeners("myProp"));
555    }
556
557    /*
558     * Test the method hasListeners(String) with a null parameter.
559     */
560    public void testHasListener_Null() {
561        Object src = new Object();
562        PropertyChangeSupport sup = new PropertyChangeSupport(src);
563        PropertyChangeListener l1 = new MockPropertyChangeListener();
564
565        assertFalse(sup.hasListeners(null));
566
567        sup.addPropertyChangeListener("myProP", l1);
568        sup.hasListeners(null);
569    }
570
571    public void testFireIndexedPropertyChange() {
572        final Object src = new Object();
573        PropertyChangeSupport pcs = new PropertyChangeSupport(src);
574        pcs.addPropertyChangeListener(new PropertyChangeListener() {
575            public void propertyChange(PropertyChangeEvent evt) {
576                assertEquals(src, evt.getSource());
577                assertEquals(0, ((IndexedPropertyChangeEvent)evt).getIndex());
578                assertEquals("one", evt.getOldValue());
579                assertEquals("two", evt.getNewValue());
580            }
581        });
582
583        pcs.fireIndexedPropertyChange("foo", 0, "one", "two");
584    }
585
586    /*
587     * Test the method firePropertyChange(String, Object, Object) with normal
588     * parameters, when there is no listeners.
589     */
590    public void testFirePropertyChange_Object_NoListeners() {
591        Object src = new Object();
592        PropertyChangeSupport sup = new PropertyChangeSupport(src);
593        sup.firePropertyChange("myProp", new Object(), new Object());
594    }
595
596    /*
597     * Test the method firePropertyChange(String, Object, Object) with normal
598     * parameters, when there is a listener for all properties and another for
599     * the named property.
600     */
601    public void testFirePropertyChange_Object_Normal() {
602        Object src = new Object();
603        PropertyChangeSupport sup = new PropertyChangeSupport(src);
604        Object newValue = new Object();
605        Object oldValue = new Object();
606
607        MockPropertyChangeListener l1 = new MockPropertyChangeListener(src,
608                "myProp", oldValue, newValue);
609        MockPropertyChangeListener l2 = new MockPropertyChangeListener(src,
610                "myProp", oldValue, newValue);
611        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
612                l2);
613        MockPropertyChangeListener l4 = new MockPropertyChangeListener(src,
614                "myProp", oldValue, newValue);
615        sup.addPropertyChangeListener(l1);
616        sup.addPropertyChangeListener(l3);
617        sup.addPropertyChangeListener("myProp", l4);
618
619        sup.firePropertyChange("myProp", oldValue, newValue);
620        l1.assertCalled();
621        l2.assertCalled();
622        l4.assertCalled();
623    }
624
625    /*
626     * Test the method firePropertyChange(String, Object, Object) with equal old
627     * and new non-null values, when there is a listener for all properties and
628     * another for the named property.
629     */
630    public void testFirePropertyChange_Object_EqualValues() {
631        Object src = new Object();
632        PropertyChangeSupport sup = new PropertyChangeSupport(src);
633        Object newValue = new Object();
634        Object oldValue = newValue;
635
636        MockPropertyChangeListener l1 = new MockPropertyChangeListener(src,
637                "myProp", oldValue, newValue);
638        MockPropertyChangeListener l2 = new MockPropertyChangeListener(src,
639                "myProp", oldValue, newValue);
640        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
641                l2);
642        MockPropertyChangeListener l4 = new MockPropertyChangeListener(src,
643                "myProp", oldValue, newValue);
644        sup.addPropertyChangeListener(l1);
645        sup.addPropertyChangeListener(l3);
646        sup.addPropertyChangeListener("myProp", l4);
647
648        sup.firePropertyChange("myProp", oldValue, newValue);
649        l1.assertNotCalled();
650        l2.assertNotCalled();
651        l4.assertNotCalled();
652    }
653
654    /*
655     * Test the method firePropertyChange(String, Object, Object) with null old
656     * and new values, when there is a listener for all properties and another
657     * for the named property.
658     */
659    public void testFirePropertyChange_Object_NullValues() {
660        Object src = new Object();
661        PropertyChangeSupport sup = new PropertyChangeSupport(src);
662        Object newValue = null;
663        Object oldValue = null;
664
665        MockPropertyChangeListener l1 = new MockPropertyChangeListener(src,
666                "myProp", oldValue, newValue);
667        MockPropertyChangeListener l2 = new MockPropertyChangeListener(src,
668                "myProp", oldValue, newValue);
669        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
670                l2);
671        MockPropertyChangeListener l4 = new MockPropertyChangeListener(src,
672                "myProp", oldValue, newValue);
673        sup.addPropertyChangeListener(l1);
674        sup.addPropertyChangeListener(l3);
675        sup.addPropertyChangeListener("myProp", l4);
676
677        sup.firePropertyChange("myProp", oldValue, newValue);
678        l1.assertCalled();
679        l2.assertCalled();
680        l4.assertCalled();
681    }
682
683    /*
684     * Test the method firePropertyChange(String, Object, Object) with a
685     * non-null old value and a null new value, when there is a listener for all
686     * properties and another for the named property.
687     */
688    public void testFirePropertyChange_Object_NullNewValue() {
689        Object src = new Object();
690        PropertyChangeSupport sup = new PropertyChangeSupport(src);
691        Object newValue = null;
692        Object oldValue = new Object();
693
694        MockPropertyChangeListener l1 = new MockPropertyChangeListener(src,
695                "myProp", oldValue, newValue);
696        MockPropertyChangeListener l2 = new MockPropertyChangeListener(src,
697                "myProp", oldValue, newValue);
698        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
699                l2);
700        MockPropertyChangeListener l4 = new MockPropertyChangeListener(src,
701                "myProp", oldValue, newValue);
702        sup.addPropertyChangeListener(l1);
703        sup.addPropertyChangeListener(l3);
704        sup.addPropertyChangeListener("myProp", l4);
705
706        sup.firePropertyChange("myProp", oldValue, newValue);
707        l1.assertCalled();
708        l2.assertCalled();
709        l4.assertCalled();
710    }
711
712    /*
713     * Test the method firePropertyChange(String, Object, Object) with a null
714     * old value and a non-null new value, when there is a listener for all
715     * properties and another for the named property.
716     */
717    public void testFirePropertyChange_Object_NullOldValue() {
718        Object src = new Object();
719        PropertyChangeSupport sup = new PropertyChangeSupport(src);
720        Object newValue = new Object();
721        Object oldValue = null;
722
723        MockPropertyChangeListener l1 = new MockPropertyChangeListener(src,
724                "myProp", oldValue, newValue);
725        MockPropertyChangeListener l2 = new MockPropertyChangeListener(src,
726                "myProp", oldValue, newValue);
727        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
728                l2);
729        MockPropertyChangeListener l4 = new MockPropertyChangeListener(src,
730                "myProp", oldValue, newValue);
731        sup.addPropertyChangeListener(l1);
732        sup.addPropertyChangeListener(l3);
733        sup.addPropertyChangeListener("myProp", l4);
734
735        sup.firePropertyChange("myProp", oldValue, newValue);
736        l1.assertCalled();
737        l2.assertCalled();
738        l4.assertCalled();
739    }
740
741    /*
742     * Test the method firePropertyChange(String, Object, Object) with a null
743     * property name parameter.
744     */
745    public void testFirePropertyChange_Object_NullProperty() {
746        Object src = new Object();
747        PropertyChangeSupport sup = new PropertyChangeSupport(src);
748        Object newValue = new Object();
749        Object oldValue = new Object();
750
751        MockPropertyChangeListener l1 = new MockPropertyChangeListener(src,
752                null, oldValue, newValue);
753        MockPropertyChangeListener l2 = new MockPropertyChangeListener(src,
754                null, oldValue, newValue);
755        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
756                l2);
757        MockPropertyChangeListener l4 = new MockPropertyChangeListener(src,
758                null, oldValue, newValue);
759        sup.addPropertyChangeListener(l1);
760        sup.addPropertyChangeListener(l3);
761        sup.addPropertyChangeListener("myProp", l4);
762
763        sup.firePropertyChange(null, oldValue, newValue);
764        l1.assertCalled();
765        l2.assertNotCalled();
766        l4.assertNotCalled();
767    }
768
769    /*
770     * Test the method firePropertyChange(String, Object, Object) when a null
771     * listener has been registered.
772     */
773    public void testFirePropertyChange_Object_NullListener() {
774        Object src = new Object();
775        PropertyChangeSupport sup = new PropertyChangeSupport(src);
776        Object newValue = new Object();
777        Object oldValue = new Object();
778
779        sup.addPropertyChangeListener(null);
780        sup.firePropertyChange("myProp", oldValue, newValue);
781    }
782
783    /*
784     * Test the method firePropertyChange(PropertyChangeEvent) with normal
785     * parameters, when there is a listener for all properties and another for
786     * the named property.
787     */
788    public void testFirePropertyChange_PropertyChangeEvent_Normal() {
789        Object src = new Object();
790        PropertyChangeSupport sup = new PropertyChangeSupport(src);
791        Object newValue = new Object();
792        Object oldValue = new Object();
793        Object src2 = new Object();
794        PropertyChangeEvent event = new PropertyChangeEvent(src2, "myProp",
795                oldValue, newValue);
796
797        MockPropertyChangeListener l1 = new MockPropertyChangeListener(src2,
798                "myProp", oldValue, newValue);
799        MockPropertyChangeListener l2 = new MockPropertyChangeListener(src2,
800                "myProp", oldValue, newValue);
801        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
802                l2);
803        MockPropertyChangeListener l4 = new MockPropertyChangeListener(src2,
804                "myProp", oldValue, newValue);
805        sup.addPropertyChangeListener(l1);
806        sup.addPropertyChangeListener(l3);
807        sup.addPropertyChangeListener("myProp", l4);
808
809        sup.firePropertyChange(event);
810        l1.assertCalled();
811        l2.assertCalled();
812        l4.assertCalled();
813    }
814
815    /*
816     * Test the method firePropertyChange(PropertyChangeEvent) with equal old
817     * and new non-null values, when there is a listener for all properties and
818     * another for the named property.
819     */
820    public void testFirePropertyChange_PropertyChangeEvent_EqualValues() {
821        Object src = new Object();
822        PropertyChangeSupport sup = new PropertyChangeSupport(src);
823        Object newValue = new Object();
824        Object oldValue = newValue;
825        Object src2 = new Object();
826        PropertyChangeEvent event = new PropertyChangeEvent(src2, "myProp",
827                oldValue, newValue);
828
829        MockPropertyChangeListener l1 = new MockPropertyChangeListener(src2,
830                "myProp", oldValue, newValue);
831        MockPropertyChangeListener l2 = new MockPropertyChangeListener(src2,
832                "myProp", oldValue, newValue);
833        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
834                l2);
835        MockPropertyChangeListener l4 = new MockPropertyChangeListener(src2,
836                "myProp", oldValue, newValue);
837        sup.addPropertyChangeListener(l1);
838        sup.addPropertyChangeListener(l3);
839        sup.addPropertyChangeListener("myProp", l4);
840
841        sup.firePropertyChange(event);
842        l1.assertNotCalled();
843        l2.assertNotCalled();
844        l4.assertNotCalled();
845    }
846
847    /*
848     * Test the method firePropertyChange(PropertyChangeEvent) with null old and
849     * new values, when there is a listener for all properties and another for
850     * the named property.
851     */
852    public void testFirePropertyChange_PropertyChangeEvent_NullValues() {
853        Object src = new Object();
854        PropertyChangeSupport sup = new PropertyChangeSupport(src);
855        Object newValue = null;
856        Object oldValue = null;
857        Object src2 = new Object();
858        PropertyChangeEvent event = new PropertyChangeEvent(src2, "myProp",
859                oldValue, newValue);
860
861        MockPropertyChangeListener l1 = new MockPropertyChangeListener(src2,
862                "myProp", oldValue, newValue);
863        MockPropertyChangeListener l2 = new MockPropertyChangeListener(src2,
864                "myProp", oldValue, newValue);
865        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
866                l2);
867        MockPropertyChangeListener l4 = new MockPropertyChangeListener(src2,
868                "myProp", oldValue, newValue);
869        sup.addPropertyChangeListener(l1);
870        sup.addPropertyChangeListener(l3);
871        sup.addPropertyChangeListener("myProp", l4);
872
873        sup.firePropertyChange(event);
874        l1.assertCalled();
875        l2.assertCalled();
876        l4.assertCalled();
877    }
878
879    /*
880     * Test the method firePropertyChange(PropertyChangeEvent) with a non-null
881     * old value and a null new value, when there is a listener for all
882     * properties and another for the named property.
883     */
884    public void testFirePropertyChange_PropertyChangeEvent_NullNewValue() {
885        Object src = new Object();
886        PropertyChangeSupport sup = new PropertyChangeSupport(src);
887        Object newValue = null;
888        Object oldValue = new Object();
889        Object src2 = new Object();
890        PropertyChangeEvent event = new PropertyChangeEvent(src2, "myProp",
891                oldValue, newValue);
892
893        MockPropertyChangeListener l1 = new MockPropertyChangeListener(src2,
894                "myProp", oldValue, newValue);
895        MockPropertyChangeListener l2 = new MockPropertyChangeListener(src2,
896                "myProp", oldValue, newValue);
897        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
898                l2);
899        MockPropertyChangeListener l4 = new MockPropertyChangeListener(src2,
900                "myProp", oldValue, newValue);
901        sup.addPropertyChangeListener(l1);
902        sup.addPropertyChangeListener(l3);
903        sup.addPropertyChangeListener("myProp", l4);
904
905        sup.firePropertyChange(event);
906        l1.assertCalled();
907        l2.assertCalled();
908        l4.assertCalled();
909    }
910
911    /*
912     * Test the method firePropertyChange(PropertyChangeEvent) with a null old
913     * value and a non-null new value, when there is a listener for all
914     * properties and another for the named property.
915     */
916    public void testFirePropertyChange_PropertyChangeEvent_NullOldValue() {
917        Object src = new Object();
918        PropertyChangeSupport sup = new PropertyChangeSupport(src);
919        Object newValue = new Object();
920        Object oldValue = null;
921        Object src2 = new Object();
922        PropertyChangeEvent event = new PropertyChangeEvent(src2, "myProp",
923                oldValue, newValue);
924
925        MockPropertyChangeListener l1 = new MockPropertyChangeListener(src2,
926                "myProp", oldValue, newValue);
927        MockPropertyChangeListener l2 = new MockPropertyChangeListener(src2,
928                "myProp", oldValue, newValue);
929        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
930                l2);
931        MockPropertyChangeListener l4 = new MockPropertyChangeListener(src2,
932                "myProp", oldValue, newValue);
933        sup.addPropertyChangeListener(l1);
934        sup.addPropertyChangeListener(l3);
935        sup.addPropertyChangeListener("myProp", l4);
936
937        sup.firePropertyChange(event);
938        l1.assertCalled();
939        l2.assertCalled();
940        l4.assertCalled();
941    }
942
943    /*
944     * Test the method firePropertyChange(PropertyChangeEvent) with a null
945     * property name parameter.
946     */
947    public void testFirePropertyChange_PropertyChangeEvent_NullProperty() {
948        Object src = new Object();
949        PropertyChangeSupport sup = new PropertyChangeSupport(src);
950        Object newValue = new Object();
951        Object oldValue = new Object();
952        Object src2 = new Object();
953        PropertyChangeEvent event = new PropertyChangeEvent(src2, null,
954                oldValue, newValue);
955
956        MockPropertyChangeListener l1 = new MockPropertyChangeListener(src2,
957                null, oldValue, newValue);
958        MockPropertyChangeListener l2 = new MockPropertyChangeListener(src2,
959                null, oldValue, newValue);
960        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
961                l2);
962        MockPropertyChangeListener l4 = new MockPropertyChangeListener(src2,
963                null, oldValue, newValue);
964        sup.addPropertyChangeListener(l1);
965        sup.addPropertyChangeListener(l3);
966        sup.addPropertyChangeListener("myProp", l4);
967
968        sup.firePropertyChange(event);
969        l1.assertCalled();
970        l2.assertNotCalled();
971        l4.assertNotCalled();
972    }
973
974    /*
975     * Test the method firePropertyChange(PropertyChangeEvent) when null.
976     */
977    public void testFirePropertyChange_PropertyChangeEvent_Null() {
978        Object src = new Object();
979        PropertyChangeSupport sup = new PropertyChangeSupport(src);
980
981        try {
982            sup.firePropertyChange(null);
983            fail("Should throw NullPointerException!");
984        } catch (NullPointerException ex) {
985            // expected
986        }
987    }
988
989    /*
990     * Test the method firePropertyChange(PropertyChangeEvent) when a null
991     * listener has been registered.
992     */
993    public void testFirePropertyChange_PropertyChangeEvent_NullListener() {
994        PropertyChangeSupport sup = new PropertyChangeSupport(new Object());
995        PropertyChangeEvent event = new PropertyChangeEvent(new Object(),
996                "myProp", new Object(), new Object());
997
998        sup.addPropertyChangeListener(null);
999        sup.firePropertyChange(event);
1000    }
1001
1002    /*
1003     * Test the method firePropertyChange(String, boolean, boolean) with normal
1004     * parameters, when there is a listener for all properties and another for
1005     * the named property.
1006     */
1007    public void testFirePropertyChange_Boolean_Normal() {
1008        Object src = new Object();
1009        PropertyChangeSupport sup = new PropertyChangeSupport(src);
1010        Object newValue = Boolean.TRUE;
1011        Object oldValue = Boolean.FALSE;
1012
1013        MockPropertyChangeListener l1 = new MockPropertyChangeListener(src,
1014                "myProp", oldValue, newValue);
1015        MockPropertyChangeListener l2 = new MockPropertyChangeListener(src,
1016                "myProp", oldValue, newValue);
1017        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
1018                l2);
1019        MockPropertyChangeListener l4 = new MockPropertyChangeListener(src,
1020                "myProp", oldValue, newValue);
1021        sup.addPropertyChangeListener(l1);
1022        sup.addPropertyChangeListener(l3);
1023        sup.addPropertyChangeListener("myProp", l4);
1024
1025        sup.firePropertyChange("myProp", false, true);
1026        l1.assertCalled();
1027        l2.assertCalled();
1028        l4.assertCalled();
1029    }
1030
1031    /*
1032     * Test the method firePropertyChange(String, boolean, boolean) with equal
1033     * old and new non-null values, when there is a listener for all properties
1034     * and another for the named property.
1035     */
1036    public void testFirePropertyChange_Boolean_EqualValues() {
1037        Object src = new Object();
1038        PropertyChangeSupport sup = new PropertyChangeSupport(src);
1039        Object newValue = Boolean.TRUE;
1040        Object oldValue = newValue;
1041
1042        MockPropertyChangeListener l1 = new MockPropertyChangeListener(src,
1043                "myProp", oldValue, newValue);
1044        MockPropertyChangeListener l2 = new MockPropertyChangeListener(src,
1045                "myProp", oldValue, newValue);
1046        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
1047                l2);
1048        MockPropertyChangeListener l4 = new MockPropertyChangeListener(src,
1049                "myProp", oldValue, newValue);
1050        sup.addPropertyChangeListener(l1);
1051        sup.addPropertyChangeListener(l3);
1052        sup.addPropertyChangeListener("myProp", l4);
1053
1054        sup.firePropertyChange("myProp", true, true);
1055        l1.assertNotCalled();
1056        l2.assertNotCalled();
1057        l4.assertNotCalled();
1058    }
1059
1060    /*
1061     * Test the method firePropertyChange(String, boolean, boolean) with a null
1062     * property name parameter.
1063     */
1064    public void testFirePropertyChange_Boolean_NullProperty() {
1065        Object src = new Object();
1066        PropertyChangeSupport sup = new PropertyChangeSupport(src);
1067        Object newValue = Boolean.TRUE;
1068        Object oldValue = Boolean.FALSE;
1069
1070        MockPropertyChangeListener l1 = new MockPropertyChangeListener(src,
1071                null, oldValue, newValue);
1072        MockPropertyChangeListener l2 = new MockPropertyChangeListener(src,
1073                null, oldValue, newValue);
1074        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
1075                l2);
1076        MockPropertyChangeListener l4 = new MockPropertyChangeListener(src,
1077                null, oldValue, newValue);
1078        sup.addPropertyChangeListener(l1);
1079        sup.addPropertyChangeListener(l3);
1080        sup.addPropertyChangeListener("myProp", l4);
1081
1082        sup.firePropertyChange(null, false, true);
1083        l1.assertCalled();
1084        l2.assertNotCalled();
1085        l4.assertNotCalled();
1086    }
1087
1088    /*
1089     * Test the method firePropertyChange(String, boolean, boolean) when a null
1090     * listener has been registered.
1091     */
1092    public void testFirePropertyChange_Boolean_NullListener() {
1093        PropertyChangeSupport sup = new PropertyChangeSupport(new Object());
1094
1095        sup.addPropertyChangeListener(null);
1096        sup.firePropertyChange("myProp", true, false);
1097    }
1098
1099    /*
1100     * Test the method firePropertyChange(String, int, int) with normal
1101     * parameters, when there is a listener for all properties and another for
1102     * the named property.
1103     */
1104    public void testFirePropertyChange_Int_Normal() {
1105        Object src = new Object();
1106        PropertyChangeSupport sup = new PropertyChangeSupport(src);
1107        int newValue = 1;
1108        int oldValue = 2;
1109
1110        MockPropertyChangeListener l1 = new MockPropertyChangeListener(src,
1111                "myProp", oldValue, newValue);
1112        MockPropertyChangeListener l2 = new MockPropertyChangeListener(src,
1113                "myProp", oldValue, newValue);
1114        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
1115                l2);
1116        MockPropertyChangeListener l4 = new MockPropertyChangeListener(src,
1117                "myProp", oldValue, newValue);
1118        sup.addPropertyChangeListener(l1);
1119        sup.addPropertyChangeListener(l3);
1120        sup.addPropertyChangeListener("myProp", l4);
1121
1122        sup.firePropertyChange("myProp", oldValue, newValue);
1123        l1.assertCalled();
1124        l2.assertCalled();
1125        l4.assertCalled();
1126    }
1127
1128    /*
1129     * Test the method firePropertyChange(String, int, int) with equal old and
1130     * new non-null values, when there is a listener for all properties and
1131     * another for the named property.
1132     */
1133    public void testFirePropertyChange_Int_EqualValues() {
1134        Object src = new Object();
1135        PropertyChangeSupport sup = new PropertyChangeSupport(src);
1136        Integer newValue = new Integer(1);
1137        Integer oldValue = newValue;
1138
1139        MockPropertyChangeListener l1 = new MockPropertyChangeListener(src,
1140                "myProp", oldValue, newValue);
1141        MockPropertyChangeListener l2 = new MockPropertyChangeListener(src,
1142                "myProp", oldValue, newValue);
1143        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
1144                l2);
1145        MockPropertyChangeListener l4 = new MockPropertyChangeListener(src,
1146                "myProp", oldValue, newValue);
1147        sup.addPropertyChangeListener(l1);
1148        sup.addPropertyChangeListener(l3);
1149        sup.addPropertyChangeListener("myProp", l4);
1150
1151        sup.firePropertyChange("myProp", oldValue.intValue(), newValue
1152                .intValue());
1153        l1.assertNotCalled();
1154        l2.assertNotCalled();
1155        l4.assertNotCalled();
1156    }
1157
1158    /*
1159     * Test the method firePropertyChange(String, int, int) with a null property
1160     * name parameter.
1161     */
1162    public void testFirePropertyChange_Int_NullProperty() {
1163        Object src = new Object();
1164        PropertyChangeSupport sup = new PropertyChangeSupport(src);
1165        Integer newValue = new Integer(1);
1166        Integer oldValue = new Integer(2);
1167
1168        MockPropertyChangeListener l1 = new MockPropertyChangeListener(src,
1169                null, oldValue, newValue);
1170        MockPropertyChangeListener l2 = new MockPropertyChangeListener(src,
1171                null, oldValue, newValue);
1172        PropertyChangeListener l3 = new PropertyChangeListenerProxy("myProp",
1173                l2);
1174        MockPropertyChangeListener l4 = new MockPropertyChangeListener(src,
1175                null, oldValue, newValue);
1176        sup.addPropertyChangeListener(l1);
1177        sup.addPropertyChangeListener(l3);
1178        sup.addPropertyChangeListener("myProp", l4);
1179
1180        sup.firePropertyChange(null, oldValue.intValue(), newValue.intValue());
1181        l1.assertCalled();
1182        l2.assertNotCalled();
1183        l4.assertNotCalled();
1184    }
1185
1186    /*
1187     * Test the method firePropertyChange(String, int, int) when a null listener
1188     * has been registered.
1189     */
1190    public void testFirePropertyChange_Int_NullListener() {
1191        Object src = new Object();
1192        PropertyChangeSupport sup = new PropertyChangeSupport(src);
1193
1194        sup.addPropertyChangeListener(null);
1195        sup.firePropertyChange("myProp", 1, 2);
1196    }
1197
1198    /*
1199     * Test serialization/deserialization.
1200     */
1201    public void testSerialization() throws Exception {
1202        Object src = "PropertyChangeSupportSerializationTest";
1203        PropertyChangeSupport sup = new PropertyChangeSupport(src);
1204        PropertyChangeSupport sup2 = new PropertyChangeSupport(src);
1205        Integer newValue = new Integer(1);
1206        Integer oldValue = new Integer(2);
1207
1208        MockPropertyChangeListener l1 = new MockPropertyChangeListener(src,
1209                "myProp", oldValue, newValue);
1210        MockPropertyChangeListener2 l2 = new MockPropertyChangeListener2();
1211
1212        sup.addPropertyChangeListener(l1);
1213        sup.addPropertyChangeListener("myProp", l1);
1214        sup.addPropertyChangeListener("myProp", l2);
1215        sup2.addPropertyChangeListener(l1);
1216        sup2.addPropertyChangeListener("myProp", l1);
1217
1218        PropertyChangeSupport deSup = (PropertyChangeSupport) SerializationTester
1219                .getDeserilizedObject(sup);
1220        assertEquals(sup2.getPropertyChangeListeners()[0], deSup
1221                .getPropertyChangeListeners()[0]);
1222        assertEquals(((PropertyChangeListenerProxy) sup2
1223                .getPropertyChangeListeners()[1]).getListener(),
1224                ((PropertyChangeListenerProxy) deSup
1225                        .getPropertyChangeListeners()[1]).getListener());
1226    }
1227
1228    /*
1229     * Test serialization/deserialization compatibility
1230     */
1231
1232    public void testSerializationCompatibility() throws Exception {
1233        Object src = "PropertyChangeSupportSerializationTest";
1234        PropertyChangeSupport sup = new PropertyChangeSupport(src);
1235        PropertyChangeSupport sup2 = new PropertyChangeSupport(src);
1236        Integer newValue = new Integer(1);
1237        Integer oldValue = new Integer(2);
1238
1239        MockPropertyChangeListener l1 = new MockPropertyChangeListener(src,
1240                "myProp", oldValue, newValue);
1241        MockPropertyChangeListener2 l2 = new MockPropertyChangeListener2();
1242
1243        sup.addPropertyChangeListener(l1);
1244        sup.addPropertyChangeListener("myProp", l1);
1245        sup.addPropertyChangeListener("myProp", l2);
1246        sup2.addPropertyChangeListener(l1);
1247        sup2.addPropertyChangeListener("myProp", l1);
1248        SerializationTest.verifyGolden(this, sup2, new SerializableAssert() {
1249            public void assertDeserialized(Serializable initial,
1250                    Serializable deserialized) {
1251                PropertyChangeSupport sup2 = (PropertyChangeSupport) initial;
1252                PropertyChangeSupport deSup = (PropertyChangeSupport) deserialized;
1253                assertEquals(sup2.getPropertyChangeListeners()[0], deSup
1254                        .getPropertyChangeListeners()[0]);
1255                assertEquals(((PropertyChangeListenerProxy) sup2
1256                        .getPropertyChangeListeners()[1]).getListener(),
1257                        ((PropertyChangeListenerProxy) deSup
1258                                .getPropertyChangeListeners()[1]).getListener());
1259            }
1260        });
1261    }
1262
1263    /*
1264     * Mock PropertyChangeListener.
1265     */
1266    static class MockPropertyChangeListener implements PropertyChangeListener,
1267            Serializable {
1268
1269        private static final long serialVersionUID = 161877638385579731L;
1270
1271        private transient Object expSrc;
1272
1273        private String expPropName;
1274
1275        private transient Object expOldValue;
1276
1277        private transient Object expNewValue;
1278
1279        private transient PropertyChangeEvent event;
1280
1281        private final transient boolean called = false;
1282
1283        public MockPropertyChangeListener() {
1284        }
1285
1286        public MockPropertyChangeListener(Object src, String propName,
1287                Object oldValue, Object newValue) {
1288            this.expSrc = src;
1289            this.expPropName = propName;
1290            this.expOldValue = oldValue;
1291            this.expNewValue = newValue;
1292        }
1293
1294        public void setAll(Object src, String propName, Object oldValue,
1295                Object newValue) {
1296            this.expSrc = src;
1297            this.expPropName = propName;
1298            this.expOldValue = oldValue;
1299            this.expNewValue = newValue;
1300        }
1301
1302        public void propertyChange(PropertyChangeEvent event) {
1303            this.event = event;
1304        }
1305
1306        public void assertCalled() {
1307            assertSame(expSrc, event.getSource());
1308            assertEquals(expPropName, event.getPropertyName());
1309            assertEquals(expOldValue, event.getOldValue());
1310            assertEquals(expNewValue, event.getNewValue());
1311            assertNull(event.getPropagationId());
1312        }
1313
1314        public void assertNotCalled() {
1315            assertNull(event);
1316            assertFalse(called);
1317        }
1318
1319        @Override
1320        public boolean equals(Object obj) {
1321            if (obj instanceof MockPropertyChangeListener) {
1322                MockPropertyChangeListener l = (MockPropertyChangeListener) obj;
1323                return null == this.expPropName ? null == l.expPropName
1324                        : this.expPropName.equals(l.expPropName);
1325            }
1326            return false;
1327        }
1328    }
1329
1330    /*
1331     * Mock PropertyChangeListener which is not serializable.
1332     */
1333    static class MockPropertyChangeListener2 implements PropertyChangeListener {
1334
1335        public void propertyChange(PropertyChangeEvent event) {
1336        }
1337    }
1338
1339    /*
1340     * Mock PropertyChangeListener that modifies the listener set on
1341     * notification.
1342     */
1343    static class MockPropertyChangeListener3 implements PropertyChangeListener {
1344
1345        PropertyChangeSupport changeSupport;
1346
1347        public MockPropertyChangeListener3(PropertyChangeSupport changeSupport) {
1348            super();
1349            this.changeSupport = changeSupport;
1350        }
1351
1352        /* On property changed event modify the listener set */
1353        public void propertyChange(PropertyChangeEvent event) {
1354            changeSupport
1355                    .addPropertyChangeListener(new PropertyChangeListener() {
1356                        public void propertyChange(PropertyChangeEvent event) {
1357                            // Empty
1358                        }
1359                    });
1360        }
1361    }
1362
1363    /**
1364     * Regression test for concurrent modification of listener set
1365     */
1366    @SuppressWarnings("unused")
1367    public void testConcurrentModification() {
1368        PropertyChangeSupport changeSupport = new PropertyChangeSupport("bogus");
1369        MockPropertyChangeListener3 changeListener = new MockPropertyChangeListener3(
1370                changeSupport);
1371        changeSupport.firePropertyChange("bogus property", "previous", "newer");
1372    }
1373
1374    /**
1375     * @tests java.beans.PropertyChangeSupport#PropertyChangeSupport(
1376     *        java.lang.Object)
1377     */
1378    public void testConstructor_Null() {
1379        // Regression for HARMONY-227
1380        try {
1381            new PropertyChangeSupport(null);
1382            fail("Should throw NullPointerException!");
1383        } catch (NullPointerException ex) {
1384            // expected
1385        }
1386    }
1387
1388    /**
1389     * @tests java.beans.PropertyChangeSupport#addPropertyChangeSupport
1390     *
1391     */
1392    public void test_addPropertyChangeListenerNullNull() throws Exception {
1393        // Regression for HARMONY-441
1394        new PropertyChangeSupport("bean1")
1395                .addPropertyChangeListener(null, null);
1396    }
1397
1398    /**
1399     * @tests java.beans.PropertyChangeSupport#removePropertyChangeListener(
1400     *        java.lang.String, java.beans.PropertyChangeListener)
1401     */
1402    public void testRemovePropertyChangeListener() {
1403        // Regression for HARMONY-386
1404        PropertyChangeSupport prop = new PropertyChangeSupport(new Object());
1405
1406        PropertyChangeListener lis1 = new PropertyChangeListener() {
1407
1408            public void propertyChange(PropertyChangeEvent event) {
1409            }
1410        };
1411
1412        PropertyChangeListener lis2 = new PropertyChangeListenerProxy("name",
1413                lis1);
1414
1415        assertEquals(0, prop.getPropertyChangeListeners().length);
1416
1417        prop.addPropertyChangeListener(lis2);
1418        assertEquals(1, prop.getPropertyChangeListeners().length);
1419
1420        prop.removePropertyChangeListener("name", lis1);
1421        assertEquals(0, prop.getPropertyChangeListeners().length);
1422    }
1423
1424    /**
1425     * @tests java.beans.PropertyChangeSupport#removePropertyChangeListener(
1426     *        java.lang.String, java.beans.PropertyChangeListener)
1427     */
1428    public void testRemovePropertyChangeListener2() {
1429        // Regression for HARMONY-320
1430        PropertyChangeListener listener = new PropertyChangeListener() {
1431
1432            public void propertyChange(PropertyChangeEvent arg0) {
1433            }
1434        };
1435
1436        PropertyChangeSupport pcs = new PropertyChangeSupport(this);
1437
1438        pcs.addPropertyChangeListener("property", listener);
1439        PropertyChangeListener[] listeners = pcs.getPropertyChangeListeners();
1440        assertEquals(1, listeners.length);
1441
1442        pcs.removePropertyChangeListener(listeners[0]);
1443        listeners = pcs.getPropertyChangeListeners();
1444        assertEquals(0, listeners.length);
1445    }
1446
1447    /**
1448     * The test checks the serialization for listeners supporting serialization
1449     */
1450    public void testSerializableListener() throws Exception {
1451        writePropertyChangeListeners(new PropertyChangeListener[] { new SerializablePropertyChangeListener() });
1452        readPropertyChangeListeners();
1453    }
1454
1455    /**
1456     * The test checks the serialization for listeners not supporting
1457     * serialization
1458     */
1459    public void testNonSerializableListener() throws Exception {
1460        writePropertyChangeListeners(new PropertyChangeListener[] { new NonSerializablePropertyChangeListener() });
1461        readPropertyChangeListeners();
1462    }
1463
1464    private void writePropertyChangeListeners(PropertyChangeListener[] array) {
1465        ObjectOutputStream oos = null;
1466        try {
1467            oos = new ObjectOutputStream(new FileOutputStream(tempFile));
1468            PropertyChangeSupport pcs = new PropertyChangeSupport("bean");
1469            if (array != null && array.length > 0) {
1470                for (PropertyChangeListener element : array) {
1471                    pcs.addPropertyChangeListener(element);
1472                }
1473            }
1474            oos.writeObject(pcs);
1475            oos.flush();
1476        } catch (Exception e) {
1477            System.out.println(e.getClass() + ": " + e.getMessage());
1478            fail("Exception is thrown in testNonSerializableListener");
1479        } finally {
1480            if (oos != null) {
1481                try {
1482                    oos.close();
1483                } catch (IOException ioe) {
1484                    fail("Exception while closing ObjectOutputStream");
1485                }
1486            }
1487        }
1488    }
1489
1490    private PropertyChangeListener[] readPropertyChangeListeners()
1491            throws Exception {
1492        ObjectInputStream ois = null;
1493        PropertyChangeSupport pcs = null;
1494        try {
1495            ois = new ObjectInputStream(new FileInputStream(tempFile));
1496            pcs = (PropertyChangeSupport) ois.readObject();
1497        } finally {
1498            if (ois != null) {
1499                ois.close();
1500            }
1501        }
1502        return pcs.getPropertyChangeListeners();
1503    }
1504}
1505