< prev index next >

modules/base/src/test/java/javafx/beans/property/ReadOnlyBooleanWrapperTest.java

Print this page
rev 9213 : 8089557: bindBidirection works for ReadOnly*Wrapper incorrectly


 138                 assertEquals(VALUE_1, p1.get());
 139                 assertEquals((Boolean)VALUE_1, p1.getValue());
 140                 assertFalse(property.isBound());
 141                 assertEquals(bean, p1.getBean());
 142                 assertEquals(name, p1.getName());
 143                 final ReadOnlyBooleanProperty r1 = p1.getReadOnlyProperty();
 144                 assertEquals(VALUE_1, r1.get());
 145                 assertEquals((Boolean)VALUE_1, r1.getValue());
 146                 assertEquals(bean, r1.getBean());
 147                 assertEquals(name, r1.getName());
 148         }
 149 
 150         @Test
 151         public void testLazySet() {
 152                 attachInvalidationListeners();
 153                 
 154                 // set value once
 155                 property.set(VALUE_1);
 156                 assertEquals(VALUE_1, property.get());
 157                 property.check(1);
 158                 internalInvalidationListener.check(readOnlyProperty, 1);
 159                 assertEquals(VALUE_1, readOnlyProperty.get());
 160                 publicInvalidationListener.check(readOnlyProperty, 1);
 161                 
 162                 // set same value again
 163                 property.set(VALUE_1);
 164                 assertEquals(VALUE_1, property.get());
 165                 property.check(0);
 166                 internalInvalidationListener.check(null, 0);
 167                 assertEquals(VALUE_1, readOnlyProperty.get());
 168                 publicInvalidationListener.check(null, 0);
 169                 
 170                 // set value twice without reading
 171                 property.set(VALUE_2);
 172                 property.set(VALUE_1);
 173                 assertEquals(VALUE_1, property.get());
 174                 property.check(1);
 175                 internalInvalidationListener.check(readOnlyProperty, 1);
 176                 assertEquals(VALUE_1, readOnlyProperty.get());
 177                 publicInvalidationListener.check(readOnlyProperty, 1);
 178         }
 179         
 180         @Test
 181         public void testInternalEagerSet() {
 182                 attachInternalChangeListener();
 183                 
 184                 // set value once
 185                 property.set(VALUE_1);
 186                 assertEquals(VALUE_1, property.get());
 187                 property.check(1);
 188                 internalChangeListener.check(readOnlyProperty, DEFAULT, VALUE_1, 1);
 189                 assertEquals(VALUE_1, readOnlyProperty.get());
 190                 
 191                 // set same value again
 192                 property.set(VALUE_1);
 193                 assertEquals(VALUE_1, property.get());
 194                 property.check(0);
 195                 internalChangeListener.check(null, UNDEFINED, UNDEFINED, 0);
 196                 assertEquals(VALUE_1, readOnlyProperty.get());
 197                 
 198                 // set value twice without reading
 199                 property.set(VALUE_2);
 200                 property.set(VALUE_1);
 201                 assertEquals(VALUE_1, property.get());
 202                 property.check(2);
 203                 internalChangeListener.check(readOnlyProperty, VALUE_2, VALUE_1, 2);
 204                 assertEquals(VALUE_1, readOnlyProperty.get());
 205         }
 206         
 207         @Test
 208         public void testPublicEagerSet() {
 209                 attachPublicChangeListener();
 210                 
 211                 // set value once
 212                 property.set(VALUE_1);
 213                 assertEquals(VALUE_1, property.get());
 214                 property.check(1);
 215                 assertEquals(VALUE_1, readOnlyProperty.get());
 216                 publicChangeListener.check(readOnlyProperty, VALUE_2, VALUE_1, 1);
 217                 
 218                 // set same value again
 219                 property.set(VALUE_1);
 220                 assertEquals(VALUE_1, property.get());
 221                 property.check(0);
 222                 assertEquals(VALUE_1, readOnlyProperty.get());
 223                 publicChangeListener.check(null, UNDEFINED, UNDEFINED, 0);
 224                 
 225                 // set value twice without reading
 226                 property.set(VALUE_2);
 227                 property.set(VALUE_1);
 228                 assertEquals(VALUE_1, property.get());
 229                 property.check(2);
 230                 assertEquals(VALUE_1, readOnlyProperty.get());
 231                 publicChangeListener.check(readOnlyProperty, VALUE_2, VALUE_1, 2);
 232         }
 233 
 234         @Test
 235         public void testLazySetValue() {
 236                 attachInvalidationListeners();
 237                 
 238                 // set value once
 239                 property.setValue(VALUE_1);
 240                 assertEquals(VALUE_1, property.get());
 241                 property.check(1);
 242                 internalInvalidationListener.check(readOnlyProperty, 1);
 243                 assertEquals(VALUE_1, readOnlyProperty.get());
 244                 publicInvalidationListener.check(readOnlyProperty, 1);
 245                 
 246                 // set same value again
 247                 property.setValue(VALUE_1);
 248                 assertEquals(VALUE_1, property.get());
 249                 property.check(0);
 250                 internalInvalidationListener.check(null, 0);
 251                 assertEquals(VALUE_1, readOnlyProperty.get());
 252                 publicInvalidationListener.check(null, 0);
 253                 
 254                 // set value twice without reading
 255                 property.setValue(VALUE_2);
 256                 property.setValue(VALUE_1);
 257                 assertEquals(VALUE_1, property.get());
 258                 property.check(1);
 259                 internalInvalidationListener.check(readOnlyProperty, 1);
 260                 assertEquals(VALUE_1, readOnlyProperty.get());
 261                 publicInvalidationListener.check(readOnlyProperty, 1);
 262         }
 263         
 264         @Test
 265         public void testInternalEagerSetValue() {
 266                 attachInternalChangeListener();
 267                 
 268                 // set value once
 269                 property.setValue(VALUE_1);
 270                 assertEquals(VALUE_1, property.get());
 271                 property.check(1);
 272                 internalChangeListener.check(readOnlyProperty, VALUE_2, VALUE_1, 1);
 273                 assertEquals(VALUE_1, readOnlyProperty.get());
 274                 
 275                 // set same value again
 276                 property.setValue(VALUE_1);
 277                 assertEquals(VALUE_1, property.get());
 278                 property.check(0);
 279                 internalChangeListener.check(null, UNDEFINED, UNDEFINED, 0);
 280                 assertEquals(VALUE_1, readOnlyProperty.get());
 281                 
 282                 // set value twice without reading
 283                 property.setValue(VALUE_2);
 284                 property.setValue(VALUE_1);
 285                 assertEquals(VALUE_1, property.get());
 286                 property.check(2);
 287                 internalChangeListener.check(readOnlyProperty, VALUE_2, VALUE_1, 2);
 288                 assertEquals(VALUE_1, readOnlyProperty.get());
 289         }
 290         
 291         @Test
 292         public void testPublicEagerSetValue() {
 293                 attachPublicChangeListener();
 294                 
 295                 // set value once
 296                 property.setValue(VALUE_1);
 297                 assertEquals(VALUE_1, property.get());
 298                 property.check(1);
 299                 assertEquals(VALUE_1, readOnlyProperty.get());
 300                 publicChangeListener.check(readOnlyProperty, VALUE_2, VALUE_1, 1);
 301                 
 302                 // set same value again
 303                 property.setValue(VALUE_1);
 304                 assertEquals(VALUE_1, property.get());
 305                 property.check(0);
 306                 assertEquals(VALUE_1, readOnlyProperty.get());
 307                 publicChangeListener.check(null, UNDEFINED, UNDEFINED, 0);


 314                 assertEquals(VALUE_1, readOnlyProperty.get());
 315                 publicChangeListener.check(readOnlyProperty, VALUE_2, VALUE_1, 2);
 316         }
 317         
 318         @Test(expected=RuntimeException.class)
 319         public void testSetBoundValue() {
 320                 final BooleanProperty v = new SimpleBooleanProperty(VALUE_1);
 321                 property.bind(v);
 322                 property.set(VALUE_1);
 323         }
 324 
 325         @Test
 326         public void testLazyBind_primitive() {
 327                 attachInvalidationListeners();
 328                 final ObservableBooleanValueStub v = new ObservableBooleanValueStub(VALUE_1);
 329 
 330                 property.bind(v);
 331                 assertEquals(VALUE_1, property.get());
 332                 assertTrue(property.isBound());
 333                 property.check(1);
 334                 internalInvalidationListener.check(readOnlyProperty, 1);
 335                 assertEquals(VALUE_1, readOnlyProperty.get());
 336                 publicInvalidationListener.check(readOnlyProperty, 1);
 337 
 338                 // change binding once
 339                 v.set(VALUE_2);
 340                 assertEquals(VALUE_2, property.get());
 341                 property.check(1);
 342                 internalInvalidationListener.check(readOnlyProperty, 1);
 343                 assertEquals(VALUE_2, readOnlyProperty.get());
 344                 publicInvalidationListener.check(readOnlyProperty, 1);
 345 
 346                 // change binding twice without reading
 347                 v.set(VALUE_1);
 348                 v.set(VALUE_2);
 349                 assertEquals(VALUE_2, property.get());
 350                 property.check(1);
 351                 internalInvalidationListener.check(readOnlyProperty, 1);
 352                 assertEquals(VALUE_2, readOnlyProperty.get());
 353                 publicInvalidationListener.check(readOnlyProperty, 1);
 354 
 355                 // change binding twice to same value
 356                 v.set(VALUE_1);
 357                 v.set(VALUE_1);
 358                 assertEquals(VALUE_1, property.get());
 359                 property.check(1);
 360                 internalInvalidationListener.check(readOnlyProperty, 1);
 361                 assertEquals(VALUE_1, readOnlyProperty.get());
 362                 publicInvalidationListener.check(readOnlyProperty, 1);
 363         }
 364 
 365         @Test
 366         public void testInternalEagerBind_primitive() {
 367                 attachInternalChangeListener();
 368                 final ObservableBooleanValueStub v = new ObservableBooleanValueStub(VALUE_1);
 369 
 370                 property.bind(v);
 371                 assertEquals(VALUE_1, property.get());
 372                 assertTrue(property.isBound());
 373                 property.check(1);
 374                 internalChangeListener.check(readOnlyProperty, VALUE_2, VALUE_1, 1);
 375                 assertEquals(VALUE_1, readOnlyProperty.get());
 376 
 377                 // change binding once
 378                 v.set(VALUE_2);
 379                 assertEquals(VALUE_2, property.get());
 380                 property.check(1);
 381                 internalChangeListener.check(readOnlyProperty, VALUE_1, VALUE_2, 1);
 382                 assertEquals(VALUE_2, readOnlyProperty.get());
 383 
 384                 // change binding twice without reading
 385                 v.set(VALUE_1);
 386                 v.set(VALUE_2);
 387                 assertEquals(VALUE_2, property.get());
 388                 property.check(2);
 389                 internalChangeListener.check(readOnlyProperty, VALUE_1, VALUE_2, 2);
 390                 assertEquals(VALUE_2, readOnlyProperty.get());
 391 
 392                 // change binding twice to same value
 393                 v.set(VALUE_1);
 394                 v.set(VALUE_1);
 395                 assertEquals(VALUE_1, property.get());
 396                 property.check(2);
 397                 internalChangeListener.check(readOnlyProperty, VALUE_2, VALUE_1, 1);
 398                 assertEquals(VALUE_1, readOnlyProperty.get());
 399         }
 400         
 401         @Test
 402         public void testPublicEagerBind_primitive() {
 403                 attachPublicChangeListener();
 404                 final ObservableBooleanValueStub v = new ObservableBooleanValueStub(VALUE_1);
 405 
 406                 property.bind(v);
 407                 assertEquals(VALUE_1, property.get());
 408                 assertTrue(property.isBound());
 409                 property.check(1);
 410                 assertEquals(VALUE_1, readOnlyProperty.get());
 411                 publicChangeListener.check(readOnlyProperty, VALUE_2, VALUE_1, 1);
 412 
 413                 // change binding once
 414                 v.set(VALUE_2);
 415                 assertEquals(VALUE_2, property.get());
 416                 property.check(1);
 417                 assertEquals(VALUE_2, readOnlyProperty.get());


 426                 publicChangeListener.check(readOnlyProperty, VALUE_1, VALUE_2, 2);
 427 
 428                 // change binding twice to same value
 429                 v.set(VALUE_1);
 430                 v.set(VALUE_1);
 431                 assertEquals(VALUE_1, property.get());
 432                 property.check(2);
 433                 assertEquals(VALUE_1, readOnlyProperty.get());
 434                 publicChangeListener.check(readOnlyProperty, VALUE_2, VALUE_1, 1);
 435         }
 436         
 437         @Test
 438         public void testLazyBind_generic() {
 439                 attachInvalidationListeners();
 440                 final ObservableObjectValueStub<Boolean> v = new ObservableObjectValueStub<Boolean>(VALUE_1);
 441 
 442                 property.bind(v);
 443                 assertEquals(VALUE_1, property.get());
 444                 assertTrue(property.isBound());
 445                 property.check(1);
 446                 internalInvalidationListener.check(readOnlyProperty, 1);
 447                 assertEquals(VALUE_1, readOnlyProperty.get());
 448                 publicInvalidationListener.check(readOnlyProperty, 1);
 449 
 450                 // change binding once
 451                 v.set(VALUE_2);
 452                 assertEquals(VALUE_2, property.get());
 453                 property.check(1);
 454                 internalInvalidationListener.check(readOnlyProperty, 1);
 455                 assertEquals(VALUE_2, readOnlyProperty.get());
 456                 publicInvalidationListener.check(readOnlyProperty, 1);
 457 
 458                 // change binding twice without reading
 459                 v.set(VALUE_1);
 460                 v.set(VALUE_2);
 461                 assertEquals(VALUE_2, property.get());
 462                 property.check(1);
 463                 internalInvalidationListener.check(readOnlyProperty, 1);
 464                 assertEquals(VALUE_2, readOnlyProperty.get());
 465                 publicInvalidationListener.check(readOnlyProperty, 1);
 466 
 467                 // change binding twice to same value
 468                 v.set(VALUE_1);
 469                 v.set(VALUE_1);
 470                 assertEquals(VALUE_1, property.get());
 471                 property.check(1);
 472                 internalInvalidationListener.check(readOnlyProperty, 1);
 473                 assertEquals(VALUE_1, readOnlyProperty.get());
 474                 publicInvalidationListener.check(readOnlyProperty, 1);
 475         }
 476 
 477         @Test
 478         public void testInternalEagerBind_generic() {
 479                 attachInternalChangeListener();
 480                 final ObservableObjectValueStub<Boolean> v = new ObservableObjectValueStub<Boolean>(VALUE_1);
 481 
 482                 property.bind(v);
 483                 assertEquals(VALUE_1, property.get());
 484                 assertTrue(property.isBound());
 485                 property.check(1);
 486                 internalChangeListener.check(readOnlyProperty, VALUE_2, VALUE_1, 1);
 487                 assertEquals(VALUE_1, readOnlyProperty.get());
 488 
 489                 // change binding once
 490                 v.set(VALUE_2);
 491                 assertEquals(VALUE_2, property.get());
 492                 property.check(1);
 493                 internalChangeListener.check(readOnlyProperty, VALUE_1, VALUE_2, 1);
 494                 assertEquals(VALUE_2, readOnlyProperty.get());
 495 
 496                 // change binding twice without reading
 497                 v.set(VALUE_1);
 498                 v.set(VALUE_2);
 499                 assertEquals(VALUE_2, property.get());
 500                 property.check(2);
 501                 internalChangeListener.check(readOnlyProperty, VALUE_1, VALUE_2, 2);
 502                 assertEquals(VALUE_2, readOnlyProperty.get());
 503 
 504                 // change binding twice to same value
 505                 v.set(VALUE_1);
 506                 v.set(VALUE_1);
 507                 assertEquals(VALUE_1, property.get());
 508                 property.check(2);
 509                 internalChangeListener.check(readOnlyProperty, VALUE_2, VALUE_1, 1);
 510                 assertEquals(VALUE_1, readOnlyProperty.get());
 511         }
 512 
 513         @Test
 514         public void testPublicEagerBind_generic() {
 515                 attachPublicChangeListener();
 516                 final ObservableObjectValueStub<Boolean> v = new ObservableObjectValueStub<Boolean>(VALUE_1);
 517 
 518                 property.bind(v);
 519                 assertEquals(VALUE_1, property.get());
 520                 assertTrue(property.isBound());
 521                 property.check(1);
 522                 assertEquals(VALUE_1, readOnlyProperty.get());
 523                 publicChangeListener.check(readOnlyProperty, VALUE_2, VALUE_1, 1);
 524 
 525                 // change binding once
 526                 v.set(VALUE_2);
 527                 assertEquals(VALUE_2, property.get());
 528                 property.check(1);
 529                 assertEquals(VALUE_2, readOnlyProperty.get());


 551                 property.bind(null);
 552         }
 553 
 554         @Test
 555         public void testRebind() {
 556         attachInvalidationListeners();
 557                 final BooleanProperty v1 = new SimpleBooleanProperty(VALUE_1);
 558                 final BooleanProperty v2 = new SimpleBooleanProperty(VALUE_2);
 559                 property.bind(v1);
 560                 property.get();
 561                 readOnlyProperty.get();
 562                 property.reset();
 563                 internalInvalidationListener.reset();
 564                 publicInvalidationListener.reset();
 565                 
 566                 // rebind causes invalidation event
 567                 property.bind(v2);
 568                 assertEquals(VALUE_2, property.get());
 569                 assertTrue(property.isBound());
 570                 property.check(1);
 571                 internalInvalidationListener.check(readOnlyProperty, 1);
 572                 assertEquals(VALUE_2, readOnlyProperty.get());
 573                 publicInvalidationListener.check(readOnlyProperty, 1);
 574                 
 575                 // change new binding
 576                 v2.set(VALUE_1);
 577                 assertEquals(VALUE_1, property.get());
 578                 property.check(1);
 579                 internalInvalidationListener.check(readOnlyProperty, 1);
 580                 assertEquals(VALUE_1, readOnlyProperty.get());
 581                 publicInvalidationListener.check(readOnlyProperty, 1);
 582                 
 583                 // change old binding
 584                 v1.set(VALUE_2);
 585                 assertEquals(VALUE_1, property.get());
 586                 property.check(0);
 587                 internalInvalidationListener.check(null, 0);
 588                 assertEquals(VALUE_1, readOnlyProperty.get());
 589                 publicInvalidationListener.check(null, 0);
 590                 
 591                 // rebind to same observable should have no effect
 592                 property.bind(v2);
 593                 assertEquals(VALUE_1, property.get());
 594                 assertTrue(property.isBound());
 595                 property.check(0);
 596                 internalInvalidationListener.check(null, 0);
 597                 assertEquals(VALUE_1, readOnlyProperty.get());
 598                 publicInvalidationListener.check(null, 0);
 599         }


 606                 property.unbind();
 607                 assertEquals(VALUE_1, property.get());
 608                 assertFalse(property.isBound());
 609                 assertEquals(VALUE_1, readOnlyProperty.get());
 610                 property.reset();
 611         internalInvalidationListener.reset();
 612         publicInvalidationListener.reset();
 613                 
 614                 // change binding
 615                 v.set(VALUE_2);
 616                 assertEquals(VALUE_1, property.get());
 617                 property.check(0);
 618                 internalInvalidationListener.check(null, 0);
 619                 assertEquals(VALUE_1, readOnlyProperty.get());
 620                 publicInvalidationListener.check(null, 0);
 621                 
 622                 // set value
 623                 property.set(VALUE_2);
 624                 assertEquals(VALUE_2, property.get());
 625                 property.check(1);
 626                 internalInvalidationListener.check(readOnlyProperty, 1);
 627                 assertEquals(VALUE_2, readOnlyProperty.get());
 628                 publicInvalidationListener.check(readOnlyProperty, 1);
 629         }
 630         
 631         @Test
 632         public void testAddingListenerWillAlwaysReceiveInvalidationEvent() {
 633                 final BooleanProperty v = new SimpleBooleanProperty(VALUE_1);
 634                 final InvalidationListenerMock internalListener2 = new InvalidationListenerMock();
 635                 final InvalidationListenerMock internalListener3 = new InvalidationListenerMock();
 636                 final InvalidationListenerMock publicListener2 = new InvalidationListenerMock();
 637                 final InvalidationListenerMock publicListener3 = new InvalidationListenerMock();
 638 
 639                 // setting the property,checking internal
 640                 property.set(VALUE_1);
 641                 property.addListener(internalListener2);
 642                 internalListener2.reset();
 643                 property.set(VALUE_2);
 644                 internalListener2.check(readOnlyProperty, 1);
 645                 
 646                 // setting the property, checking public
 647                 property.set(VALUE_1);
 648                 readOnlyProperty.addListener(publicListener2);
 649                 publicListener2.reset();
 650                 property.set(VALUE_2);
 651                 publicListener2.check(readOnlyProperty, 1);
 652                 
 653                 // binding the property, checking internal
 654                 property.bind(v);
 655                 v.set(VALUE_2);
 656                 property.addListener(internalListener3);
 657                 v.get();
 658                 internalListener3.reset();
 659                 v.set(VALUE_1);
 660                 internalListener3.check(readOnlyProperty, 1);
 661                 
 662                 // binding the property, checking public
 663                 property.bind(v);
 664                 v.set(VALUE_2);
 665                 readOnlyProperty.addListener(publicListener3);
 666                 v.get();
 667                 publicListener3.reset();
 668                 v.set(VALUE_1);
 669                 publicListener3.check(readOnlyProperty, 1);
 670         }
 671         
 672         @Test
 673         public void testRemoveListeners() {
 674                 attachInvalidationListeners();
 675                 attachInternalChangeListener();
 676                 property.removeListener(internalInvalidationListener);
 677                 property.removeListener(internalChangeListener);
 678                 property.get();
 679                 internalInvalidationListener.reset();
 680                 internalChangeListener.reset();




 138                 assertEquals(VALUE_1, p1.get());
 139                 assertEquals((Boolean)VALUE_1, p1.getValue());
 140                 assertFalse(property.isBound());
 141                 assertEquals(bean, p1.getBean());
 142                 assertEquals(name, p1.getName());
 143                 final ReadOnlyBooleanProperty r1 = p1.getReadOnlyProperty();
 144                 assertEquals(VALUE_1, r1.get());
 145                 assertEquals((Boolean)VALUE_1, r1.getValue());
 146                 assertEquals(bean, r1.getBean());
 147                 assertEquals(name, r1.getName());
 148         }
 149 
 150         @Test
 151         public void testLazySet() {
 152                 attachInvalidationListeners();
 153                 
 154                 // set value once
 155                 property.set(VALUE_1);
 156                 assertEquals(VALUE_1, property.get());
 157                 property.check(1);
 158                 internalInvalidationListener.check(property, 1);
 159                 assertEquals(VALUE_1, readOnlyProperty.get());
 160                 publicInvalidationListener.check(readOnlyProperty, 1);
 161                 
 162                 // set same value again
 163                 property.set(VALUE_1);
 164                 assertEquals(VALUE_1, property.get());
 165                 property.check(0);
 166                 internalInvalidationListener.check(null, 0);
 167                 assertEquals(VALUE_1, readOnlyProperty.get());
 168                 publicInvalidationListener.check(null, 0);
 169                 
 170                 // set value twice without reading
 171                 property.set(VALUE_2);
 172                 property.set(VALUE_1);
 173                 assertEquals(VALUE_1, property.get());
 174                 property.check(1);
 175                 internalInvalidationListener.check(property, 1);
 176                 assertEquals(VALUE_1, readOnlyProperty.get());
 177                 publicInvalidationListener.check(readOnlyProperty, 1);
 178         }
 179         
 180         @Test
 181         public void testInternalEagerSet() {
 182                 attachInternalChangeListener();
 183                 
 184                 // set value once
 185                 property.set(VALUE_1);
 186                 assertEquals(VALUE_1, property.get());
 187                 property.check(1);
 188                 internalChangeListener.check(property, DEFAULT, VALUE_1, 1);
 189                 assertEquals(VALUE_1, readOnlyProperty.get());
 190                 
 191                 // set same value again
 192                 property.set(VALUE_1);
 193                 assertEquals(VALUE_1, property.get());
 194                 property.check(0);
 195                 internalChangeListener.check(null, UNDEFINED, UNDEFINED, 0);
 196                 assertEquals(VALUE_1, readOnlyProperty.get());
 197                 
 198                 // set value twice without reading
 199                 property.set(VALUE_2);
 200                 property.set(VALUE_1);
 201                 assertEquals(VALUE_1, property.get());
 202                 property.check(2);
 203                 internalChangeListener.check(property, VALUE_2, VALUE_1, 2);
 204                 assertEquals(VALUE_1, readOnlyProperty.get());
 205         }
 206         
 207         @Test
 208         public void testPublicEagerSet() {
 209                 attachPublicChangeListener();
 210                 
 211                 // set value once
 212                 property.set(VALUE_1);
 213                 assertEquals(VALUE_1, property.get());
 214                 property.check(1);
 215                 assertEquals(VALUE_1, readOnlyProperty.get());
 216                 publicChangeListener.check(readOnlyProperty, VALUE_2, VALUE_1, 1);
 217                 
 218                 // set same value again
 219                 property.set(VALUE_1);
 220                 assertEquals(VALUE_1, property.get());
 221                 property.check(0);
 222                 assertEquals(VALUE_1, readOnlyProperty.get());
 223                 publicChangeListener.check(null, UNDEFINED, UNDEFINED, 0);
 224                 
 225                 // set value twice without reading
 226                 property.set(VALUE_2);
 227                 property.set(VALUE_1);
 228                 assertEquals(VALUE_1, property.get());
 229                 property.check(2);
 230                 assertEquals(VALUE_1, readOnlyProperty.get());
 231                 publicChangeListener.check(readOnlyProperty, VALUE_2, VALUE_1, 2);
 232         }
 233 
 234         @Test
 235         public void testLazySetValue() {
 236                 attachInvalidationListeners();
 237                 
 238                 // set value once
 239                 property.setValue(VALUE_1);
 240                 assertEquals(VALUE_1, property.get());
 241                 property.check(1);
 242                 internalInvalidationListener.check(property, 1);
 243                 assertEquals(VALUE_1, readOnlyProperty.get());
 244                 publicInvalidationListener.check(readOnlyProperty, 1);
 245                 
 246                 // set same value again
 247                 property.setValue(VALUE_1);
 248                 assertEquals(VALUE_1, property.get());
 249                 property.check(0);
 250                 internalInvalidationListener.check(null, 0);
 251                 assertEquals(VALUE_1, readOnlyProperty.get());
 252                 publicInvalidationListener.check(null, 0);
 253                 
 254                 // set value twice without reading
 255                 property.setValue(VALUE_2);
 256                 property.setValue(VALUE_1);
 257                 assertEquals(VALUE_1, property.get());
 258                 property.check(1);
 259                 internalInvalidationListener.check(property, 1);
 260                 assertEquals(VALUE_1, readOnlyProperty.get());
 261                 publicInvalidationListener.check(readOnlyProperty, 1);
 262         }
 263         
 264         @Test
 265         public void testInternalEagerSetValue() {
 266                 attachInternalChangeListener();
 267                 
 268                 // set value once
 269                 property.setValue(VALUE_1);
 270                 assertEquals(VALUE_1, property.get());
 271                 property.check(1);
 272                 internalChangeListener.check(property, VALUE_2, VALUE_1, 1);
 273                 assertEquals(VALUE_1, readOnlyProperty.get());
 274                 
 275                 // set same value again
 276                 property.setValue(VALUE_1);
 277                 assertEquals(VALUE_1, property.get());
 278                 property.check(0);
 279                 internalChangeListener.check(null, UNDEFINED, UNDEFINED, 0);
 280                 assertEquals(VALUE_1, readOnlyProperty.get());
 281                 
 282                 // set value twice without reading
 283                 property.setValue(VALUE_2);
 284                 property.setValue(VALUE_1);
 285                 assertEquals(VALUE_1, property.get());
 286                 property.check(2);
 287                 internalChangeListener.check(property, VALUE_2, VALUE_1, 2);
 288                 assertEquals(VALUE_1, readOnlyProperty.get());
 289         }
 290         
 291         @Test
 292         public void testPublicEagerSetValue() {
 293                 attachPublicChangeListener();
 294                 
 295                 // set value once
 296                 property.setValue(VALUE_1);
 297                 assertEquals(VALUE_1, property.get());
 298                 property.check(1);
 299                 assertEquals(VALUE_1, readOnlyProperty.get());
 300                 publicChangeListener.check(readOnlyProperty, VALUE_2, VALUE_1, 1);
 301                 
 302                 // set same value again
 303                 property.setValue(VALUE_1);
 304                 assertEquals(VALUE_1, property.get());
 305                 property.check(0);
 306                 assertEquals(VALUE_1, readOnlyProperty.get());
 307                 publicChangeListener.check(null, UNDEFINED, UNDEFINED, 0);


 314                 assertEquals(VALUE_1, readOnlyProperty.get());
 315                 publicChangeListener.check(readOnlyProperty, VALUE_2, VALUE_1, 2);
 316         }
 317         
 318         @Test(expected=RuntimeException.class)
 319         public void testSetBoundValue() {
 320                 final BooleanProperty v = new SimpleBooleanProperty(VALUE_1);
 321                 property.bind(v);
 322                 property.set(VALUE_1);
 323         }
 324 
 325         @Test
 326         public void testLazyBind_primitive() {
 327                 attachInvalidationListeners();
 328                 final ObservableBooleanValueStub v = new ObservableBooleanValueStub(VALUE_1);
 329 
 330                 property.bind(v);
 331                 assertEquals(VALUE_1, property.get());
 332                 assertTrue(property.isBound());
 333                 property.check(1);
 334                 internalInvalidationListener.check(property, 1);
 335                 assertEquals(VALUE_1, readOnlyProperty.get());
 336                 publicInvalidationListener.check(readOnlyProperty, 1);
 337 
 338                 // change binding once
 339                 v.set(VALUE_2);
 340                 assertEquals(VALUE_2, property.get());
 341                 property.check(1);
 342                 internalInvalidationListener.check(property, 1);
 343                 assertEquals(VALUE_2, readOnlyProperty.get());
 344                 publicInvalidationListener.check(readOnlyProperty, 1);
 345 
 346                 // change binding twice without reading
 347                 v.set(VALUE_1);
 348                 v.set(VALUE_2);
 349                 assertEquals(VALUE_2, property.get());
 350                 property.check(1);
 351                 internalInvalidationListener.check(property, 1);
 352                 assertEquals(VALUE_2, readOnlyProperty.get());
 353                 publicInvalidationListener.check(readOnlyProperty, 1);
 354 
 355                 // change binding twice to same value
 356                 v.set(VALUE_1);
 357                 v.set(VALUE_1);
 358                 assertEquals(VALUE_1, property.get());
 359                 property.check(1);
 360                 internalInvalidationListener.check(property, 1);
 361                 assertEquals(VALUE_1, readOnlyProperty.get());
 362                 publicInvalidationListener.check(readOnlyProperty, 1);
 363         }
 364 
 365         @Test
 366         public void testInternalEagerBind_primitive() {
 367                 attachInternalChangeListener();
 368                 final ObservableBooleanValueStub v = new ObservableBooleanValueStub(VALUE_1);
 369 
 370                 property.bind(v);
 371                 assertEquals(VALUE_1, property.get());
 372                 assertTrue(property.isBound());
 373                 property.check(1);
 374                 internalChangeListener.check(property, VALUE_2, VALUE_1, 1);
 375                 assertEquals(VALUE_1, readOnlyProperty.get());
 376 
 377                 // change binding once
 378                 v.set(VALUE_2);
 379                 assertEquals(VALUE_2, property.get());
 380                 property.check(1);
 381                 internalChangeListener.check(property, VALUE_1, VALUE_2, 1);
 382                 assertEquals(VALUE_2, readOnlyProperty.get());
 383 
 384                 // change binding twice without reading
 385                 v.set(VALUE_1);
 386                 v.set(VALUE_2);
 387                 assertEquals(VALUE_2, property.get());
 388                 property.check(2);
 389                 internalChangeListener.check(property, VALUE_1, VALUE_2, 2);
 390                 assertEquals(VALUE_2, readOnlyProperty.get());
 391 
 392                 // change binding twice to same value
 393                 v.set(VALUE_1);
 394                 v.set(VALUE_1);
 395                 assertEquals(VALUE_1, property.get());
 396                 property.check(2);
 397                 internalChangeListener.check(property, VALUE_2, VALUE_1, 1);
 398                 assertEquals(VALUE_1, readOnlyProperty.get());
 399         }
 400         
 401         @Test
 402         public void testPublicEagerBind_primitive() {
 403                 attachPublicChangeListener();
 404                 final ObservableBooleanValueStub v = new ObservableBooleanValueStub(VALUE_1);
 405 
 406                 property.bind(v);
 407                 assertEquals(VALUE_1, property.get());
 408                 assertTrue(property.isBound());
 409                 property.check(1);
 410                 assertEquals(VALUE_1, readOnlyProperty.get());
 411                 publicChangeListener.check(readOnlyProperty, VALUE_2, VALUE_1, 1);
 412 
 413                 // change binding once
 414                 v.set(VALUE_2);
 415                 assertEquals(VALUE_2, property.get());
 416                 property.check(1);
 417                 assertEquals(VALUE_2, readOnlyProperty.get());


 426                 publicChangeListener.check(readOnlyProperty, VALUE_1, VALUE_2, 2);
 427 
 428                 // change binding twice to same value
 429                 v.set(VALUE_1);
 430                 v.set(VALUE_1);
 431                 assertEquals(VALUE_1, property.get());
 432                 property.check(2);
 433                 assertEquals(VALUE_1, readOnlyProperty.get());
 434                 publicChangeListener.check(readOnlyProperty, VALUE_2, VALUE_1, 1);
 435         }
 436         
 437         @Test
 438         public void testLazyBind_generic() {
 439                 attachInvalidationListeners();
 440                 final ObservableObjectValueStub<Boolean> v = new ObservableObjectValueStub<Boolean>(VALUE_1);
 441 
 442                 property.bind(v);
 443                 assertEquals(VALUE_1, property.get());
 444                 assertTrue(property.isBound());
 445                 property.check(1);
 446                 internalInvalidationListener.check(property, 1);
 447                 assertEquals(VALUE_1, readOnlyProperty.get());
 448                 publicInvalidationListener.check(readOnlyProperty, 1);
 449 
 450                 // change binding once
 451                 v.set(VALUE_2);
 452                 assertEquals(VALUE_2, property.get());
 453                 property.check(1);
 454                 internalInvalidationListener.check(property, 1);
 455                 assertEquals(VALUE_2, readOnlyProperty.get());
 456                 publicInvalidationListener.check(readOnlyProperty, 1);
 457 
 458                 // change binding twice without reading
 459                 v.set(VALUE_1);
 460                 v.set(VALUE_2);
 461                 assertEquals(VALUE_2, property.get());
 462                 property.check(1);
 463                 internalInvalidationListener.check(property, 1);
 464                 assertEquals(VALUE_2, readOnlyProperty.get());
 465                 publicInvalidationListener.check(readOnlyProperty, 1);
 466 
 467                 // change binding twice to same value
 468                 v.set(VALUE_1);
 469                 v.set(VALUE_1);
 470                 assertEquals(VALUE_1, property.get());
 471                 property.check(1);
 472                 internalInvalidationListener.check(property, 1);
 473                 assertEquals(VALUE_1, readOnlyProperty.get());
 474                 publicInvalidationListener.check(readOnlyProperty, 1);
 475         }
 476 
 477         @Test
 478         public void testInternalEagerBind_generic() {
 479                 attachInternalChangeListener();
 480                 final ObservableObjectValueStub<Boolean> v = new ObservableObjectValueStub<Boolean>(VALUE_1);
 481 
 482                 property.bind(v);
 483                 assertEquals(VALUE_1, property.get());
 484                 assertTrue(property.isBound());
 485                 property.check(1);
 486                 internalChangeListener.check(property, VALUE_2, VALUE_1, 1);
 487                 assertEquals(VALUE_1, readOnlyProperty.get());
 488 
 489                 // change binding once
 490                 v.set(VALUE_2);
 491                 assertEquals(VALUE_2, property.get());
 492                 property.check(1);
 493                 internalChangeListener.check(property, VALUE_1, VALUE_2, 1);
 494                 assertEquals(VALUE_2, readOnlyProperty.get());
 495 
 496                 // change binding twice without reading
 497                 v.set(VALUE_1);
 498                 v.set(VALUE_2);
 499                 assertEquals(VALUE_2, property.get());
 500                 property.check(2);
 501                 internalChangeListener.check(property, VALUE_1, VALUE_2, 2);
 502                 assertEquals(VALUE_2, readOnlyProperty.get());
 503 
 504                 // change binding twice to same value
 505                 v.set(VALUE_1);
 506                 v.set(VALUE_1);
 507                 assertEquals(VALUE_1, property.get());
 508                 property.check(2);
 509                 internalChangeListener.check(property, VALUE_2, VALUE_1, 1);
 510                 assertEquals(VALUE_1, readOnlyProperty.get());
 511         }
 512 
 513         @Test
 514         public void testPublicEagerBind_generic() {
 515                 attachPublicChangeListener();
 516                 final ObservableObjectValueStub<Boolean> v = new ObservableObjectValueStub<Boolean>(VALUE_1);
 517 
 518                 property.bind(v);
 519                 assertEquals(VALUE_1, property.get());
 520                 assertTrue(property.isBound());
 521                 property.check(1);
 522                 assertEquals(VALUE_1, readOnlyProperty.get());
 523                 publicChangeListener.check(readOnlyProperty, VALUE_2, VALUE_1, 1);
 524 
 525                 // change binding once
 526                 v.set(VALUE_2);
 527                 assertEquals(VALUE_2, property.get());
 528                 property.check(1);
 529                 assertEquals(VALUE_2, readOnlyProperty.get());


 551                 property.bind(null);
 552         }
 553 
 554         @Test
 555         public void testRebind() {
 556         attachInvalidationListeners();
 557                 final BooleanProperty v1 = new SimpleBooleanProperty(VALUE_1);
 558                 final BooleanProperty v2 = new SimpleBooleanProperty(VALUE_2);
 559                 property.bind(v1);
 560                 property.get();
 561                 readOnlyProperty.get();
 562                 property.reset();
 563                 internalInvalidationListener.reset();
 564                 publicInvalidationListener.reset();
 565                 
 566                 // rebind causes invalidation event
 567                 property.bind(v2);
 568                 assertEquals(VALUE_2, property.get());
 569                 assertTrue(property.isBound());
 570                 property.check(1);
 571                 internalInvalidationListener.check(property, 1);
 572                 assertEquals(VALUE_2, readOnlyProperty.get());
 573                 publicInvalidationListener.check(readOnlyProperty, 1);
 574                 
 575                 // change new binding
 576                 v2.set(VALUE_1);
 577                 assertEquals(VALUE_1, property.get());
 578                 property.check(1);
 579                 internalInvalidationListener.check(property, 1);
 580                 assertEquals(VALUE_1, readOnlyProperty.get());
 581                 publicInvalidationListener.check(readOnlyProperty, 1);
 582                 
 583                 // change old binding
 584                 v1.set(VALUE_2);
 585                 assertEquals(VALUE_1, property.get());
 586                 property.check(0);
 587                 internalInvalidationListener.check(null, 0);
 588                 assertEquals(VALUE_1, readOnlyProperty.get());
 589                 publicInvalidationListener.check(null, 0);
 590                 
 591                 // rebind to same observable should have no effect
 592                 property.bind(v2);
 593                 assertEquals(VALUE_1, property.get());
 594                 assertTrue(property.isBound());
 595                 property.check(0);
 596                 internalInvalidationListener.check(null, 0);
 597                 assertEquals(VALUE_1, readOnlyProperty.get());
 598                 publicInvalidationListener.check(null, 0);
 599         }


 606                 property.unbind();
 607                 assertEquals(VALUE_1, property.get());
 608                 assertFalse(property.isBound());
 609                 assertEquals(VALUE_1, readOnlyProperty.get());
 610                 property.reset();
 611         internalInvalidationListener.reset();
 612         publicInvalidationListener.reset();
 613                 
 614                 // change binding
 615                 v.set(VALUE_2);
 616                 assertEquals(VALUE_1, property.get());
 617                 property.check(0);
 618                 internalInvalidationListener.check(null, 0);
 619                 assertEquals(VALUE_1, readOnlyProperty.get());
 620                 publicInvalidationListener.check(null, 0);
 621                 
 622                 // set value
 623                 property.set(VALUE_2);
 624                 assertEquals(VALUE_2, property.get());
 625                 property.check(1);
 626                 internalInvalidationListener.check(property, 1);
 627                 assertEquals(VALUE_2, readOnlyProperty.get());
 628                 publicInvalidationListener.check(readOnlyProperty, 1);
 629         }
 630         
 631         @Test
 632         public void testAddingListenerWillAlwaysReceiveInvalidationEvent() {
 633                 final BooleanProperty v = new SimpleBooleanProperty(VALUE_1);
 634                 final InvalidationListenerMock internalListener2 = new InvalidationListenerMock();
 635                 final InvalidationListenerMock internalListener3 = new InvalidationListenerMock();
 636                 final InvalidationListenerMock publicListener2 = new InvalidationListenerMock();
 637                 final InvalidationListenerMock publicListener3 = new InvalidationListenerMock();
 638 
 639                 // setting the property,checking internal
 640                 property.set(VALUE_1);
 641                 property.addListener(internalListener2);
 642                 internalListener2.reset();
 643                 property.set(VALUE_2);
 644                 internalListener2.check(property, 1);
 645                 
 646                 // setting the property, checking public
 647                 property.set(VALUE_1);
 648                 readOnlyProperty.addListener(publicListener2);
 649                 publicListener2.reset();
 650                 property.set(VALUE_2);
 651                 publicListener2.check(readOnlyProperty, 1);
 652                 
 653                 // binding the property, checking internal
 654                 property.bind(v);
 655                 v.set(VALUE_2);
 656                 property.addListener(internalListener3);
 657                 v.get();
 658                 internalListener3.reset();
 659                 v.set(VALUE_1);
 660                 internalListener3.check(property, 1);
 661                 
 662                 // binding the property, checking public
 663                 property.bind(v);
 664                 v.set(VALUE_2);
 665                 readOnlyProperty.addListener(publicListener3);
 666                 v.get();
 667                 publicListener3.reset();
 668                 v.set(VALUE_1);
 669                 publicListener3.check(readOnlyProperty, 1);
 670         }
 671         
 672         @Test
 673         public void testRemoveListeners() {
 674                 attachInvalidationListeners();
 675                 attachInternalChangeListener();
 676                 property.removeListener(internalInvalidationListener);
 677                 property.removeListener(internalChangeListener);
 678                 property.get();
 679                 internalInvalidationListener.reset();
 680                 internalChangeListener.reset();


< prev index next >