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 18 package org.apache.harmony.beans.tests.java.beans; 19 20 import java.beans.IndexedPropertyChangeEvent; 21 import java.beans.PropertyChangeEvent; 22 import java.beans.PropertyChangeListener; 23 import java.beans.PropertyChangeListenerProxy; 24 import java.beans.PropertyChangeSupport; 25 import java.io.File; 26 import java.io.FileInputStream; 27 import java.io.FileOutputStream; 28 import java.io.IOException; 29 import java.io.ObjectInputStream; 30 import java.io.ObjectOutputStream; 31 import java.io.Serializable; 32 33 import junit.framework.TestCase; 34 35 import org.apache.harmony.beans.tests.support.NonSerializablePropertyChangeListener; 36 import org.apache.harmony.beans.tests.support.SerializablePropertyChangeListener; 37 import org.apache.harmony.testframework.serialization.SerializationTest; 38 import org.apache.harmony.testframework.serialization.SerializationTest.SerializableAssert; 39 40 import tests.util.SerializationTester; 41 42 /** 43 * Test class PropertyChangeSupport. 44 */ 45 public 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
