1 /* 2 * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 24 import java.beans.BeanInfo; 25 import java.beans.BeanProperty; 26 import java.beans.IntrospectionException; 27 import java.beans.Introspector; 28 import java.beans.PropertyChangeListener; 29 import java.beans.PropertyDescriptor; 30 31 import java.util.Arrays; 32 33 34 /** 35 * @test 36 * @bug 8132973 8132732 8155013 37 * @summary Some check for BeanProperty annotation 38 * @author a.stepanov 39 * @run main AnonymousClassBeanPropertyTest 40 */ 41 42 43 public class AnonymousClassBeanPropertyTest { 44 45 private final static String DESCRIPTION = "TEST"; 46 private final static boolean BOUND = true; 47 private final static boolean EXPERT = false; 48 private final static boolean HIDDEN = true; 49 private final static boolean PREFERRED = false; 50 private final static boolean REQUIRED = true; 51 private final static boolean UPDATE = false; 52 53 private final static double X = java.lang.Math.PI; 54 55 private final static String 56 V_NAME = "java.lang.Math.PI", 57 V_SHORT = "PI", 58 V = Double.toString(X); 59 60 private final static String DESCRIPTION_2 = "XYZ"; 61 62 63 // ---------- test cases (interfaces) ---------- 64 65 private interface IGet { 66 double getX(); 67 } 68 69 private interface ISet { 70 void setX(double v); 71 } 72 73 private interface IGetByIndex { 74 double getX(int i); 75 } 76 77 private interface ISetByIndex { 78 void setX(int i, double v); 79 } 80 81 private interface IGetArray { 82 double[] getX(); 83 } 84 85 private interface ISetArray { 86 void setX(double a[]); 87 } 88 89 private interface IGetBoth { 90 double getX(int i); 91 double[] getX(); 92 } 93 94 private interface ISetBoth { 95 void setX(int i, double v); 96 void setX(double a[]); 97 } 98 99 private interface IGetSet { 100 double getX(); 101 void setX(double v); 102 } 103 104 private interface IGetSetByIndex { 105 double getX(int i); 106 void setX(int i, double v); 107 } 108 109 private interface IGetSetBoth { 110 double getX(int i); 111 double[] getX(); 112 void setX(int i, double v); 113 void setX(double a[]); 114 } 115 116 117 // ---------- checks ---------- 118 119 private static boolean check(String what, boolean v, boolean ref) { 120 121 boolean ok = (v == ref); 122 if (!ok) { System.out.println( 123 "invalid " + what + ": " + v + ", expected: " + ref); } 124 return ok; 125 } 126 127 private static boolean checkInfo(Class<?> c, String what) { 128 129 BeanInfo i; 130 try { i = Introspector.getBeanInfo(c, Object.class); } 131 catch (IntrospectionException e) { throw new RuntimeException(e); } 132 133 System.out.println("\nchecking info for " + what); 134 135 PropertyDescriptor descriptors[] = i.getPropertyDescriptors(); 136 int nd = descriptors.length; 137 if (nd != 1) { 138 System.out.println("invalid number of descriptors: " + nd); 139 return false; 140 } 141 142 PropertyDescriptor d = descriptors[0]; 143 144 String descr = d.getShortDescription(); 145 boolean ok = descr.equals(DESCRIPTION); 146 if (!ok) { System.out.println("invalid description: " + descr + 147 ", expected: " + DESCRIPTION); } 148 149 ok &= check("isBound", d.isBound(), BOUND); 150 ok &= check("isExpert", d.isExpert(), EXPERT); 151 ok &= check("isHidden", d.isHidden(), HIDDEN); 152 ok &= check("isPreferred", d.isPreferred(), PREFERRED); 153 ok &= check("required", (boolean) d.getValue("required"), REQUIRED); 154 ok &= check("visualUpdate", 155 (boolean) d.getValue("visualUpdate"), UPDATE); 156 157 Object vals[] = (Object[]) d.getValue("enumerationValues"); 158 if (vals == null) { 159 System.out.println("null enumerationValues"); 160 return false; 161 } 162 163 if (vals.length == 0) { 164 System.out.println("empty enumerationValues"); 165 return false; 166 } 167 168 boolean okVals = ( 169 (vals.length == 3) && 170 vals[0].toString().equals(V_SHORT) && 171 vals[1].toString().equals(V) && 172 vals[2].toString().equals(V_NAME)); 173 174 if (!okVals) { 175 System.out.println("invalid enumerationValues:"); 176 for (Object v: vals) { System.out.println(v.toString()); } 177 } 178 179 return (ok && okVals); 180 } 181 182 private static boolean checkAlternativeInfo(Class<?> c, String what) { 183 184 BeanInfo i; 185 try { i = Introspector.getBeanInfo(c, Object.class); } 186 catch (IntrospectionException e) { throw new RuntimeException(e); } 187 188 System.out.println("checking alternative info for " + what); 189 190 PropertyDescriptor descriptors[] = i.getPropertyDescriptors(); 191 int nd = descriptors.length; 192 if (nd != 1) { 193 System.out.println("invalid number of descriptors: " + nd); 194 return false; 195 } 196 197 PropertyDescriptor d = descriptors[0]; 198 199 String descr = d.getShortDescription(); 200 boolean ok = descr.equals(DESCRIPTION_2); 201 if (!ok) { System.out.println("invalid alternative description: " + 202 descr + ", expected: " + DESCRIPTION_2); } 203 204 ok &= check("isBound", d.isBound(), !BOUND); 205 ok &= check("isExpert", d.isExpert(), !EXPERT); 206 ok &= check("isHidden", d.isHidden(), !HIDDEN); 207 ok &= check("isPreferred", d.isPreferred(), !PREFERRED); 208 ok &= check("required", (boolean) d.getValue("required"), !REQUIRED); 209 ok &= check("visualUpdate", 210 (boolean) d.getValue("visualUpdate"), !UPDATE); 211 212 Object vals[] = (Object[]) d.getValue("enumerationValues"); 213 if (vals != null || vals.length > 0) { 214 System.out.println("non-empty enumerationValues"); 215 return false; 216 } 217 218 return ok; 219 } 220 221 222 223 // ---------- run tests ---------- 224 225 public static void main(String[] args) { 226 227 boolean passed = true, ok, ok2; 228 229 //---------------------------------------------------------------------- 230 231 IGet testGet = new IGet() { 232 @BeanProperty( 233 description = DESCRIPTION, 234 bound = BOUND, 235 expert = EXPERT, 236 hidden = HIDDEN, 237 preferred = PREFERRED, 238 required = REQUIRED, 239 visualUpdate = UPDATE, 240 enumerationValues = {V_NAME}) 241 @Override 242 public double getX() { return X; } 243 244 public void addPropertyChangeListener(PropertyChangeListener l) {} 245 public void removePropertyChangeListener(PropertyChangeListener l) {} 246 }; 247 ok = checkInfo(testGet.getClass(), "IGet"); 248 System.out.println("OK = " + ok); 249 passed = passed && ok; 250 251 //---------------------------------------------------------------------- 252 253 ISet testSet = new ISet() { 254 255 private double x; 256 257 @BeanProperty( 258 description = DESCRIPTION, 259 bound = BOUND, 260 expert = EXPERT, 261 hidden = HIDDEN, 262 preferred = PREFERRED, 263 required = REQUIRED, 264 visualUpdate = UPDATE, 265 enumerationValues = {V_NAME}) 266 @Override 267 public void setX(double v) { x = v; } 268 269 public void addPropertyChangeListener(PropertyChangeListener l) {} 270 public void removePropertyChangeListener(PropertyChangeListener l) {} 271 }; 272 ok = checkInfo(testSet.getClass(), "ISet"); 273 System.out.println("OK = " + ok); 274 passed = passed && ok; 275 276 //---------------------------------------------------------------------- 277 278 IGetByIndex testGetByIndex = new IGetByIndex() { 279 280 private final double x[] = {X, X}; 281 282 @BeanProperty( 283 description = DESCRIPTION, 284 bound = BOUND, 285 expert = EXPERT, 286 hidden = HIDDEN, 287 preferred = PREFERRED, 288 required = REQUIRED, 289 visualUpdate = UPDATE, 290 enumerationValues = {V_NAME}) 291 @Override 292 public double getX(int i) { return x[i]; } 293 294 public void addPropertyChangeListener(PropertyChangeListener l) {} 295 public void removePropertyChangeListener(PropertyChangeListener l) {} 296 }; 297 ok = checkInfo(testGetByIndex.getClass(), "IGetByIndex"); 298 System.out.println("OK = " + ok); 299 passed = passed && ok; 300 301 //---------------------------------------------------------------------- 302 303 ISetByIndex testSetByIndex = new ISetByIndex() { 304 305 private final double x[] = {X, X, X}; 306 307 @BeanProperty( 308 description = DESCRIPTION, 309 bound = BOUND, 310 expert = EXPERT, 311 hidden = HIDDEN, 312 preferred = PREFERRED, 313 required = REQUIRED, 314 visualUpdate = UPDATE, 315 enumerationValues = {V_NAME}) 316 @Override 317 public void setX(int i, double v) { x[i] = v; } 318 319 public void addPropertyChangeListener(PropertyChangeListener l) {} 320 public void removePropertyChangeListener(PropertyChangeListener l) {} 321 }; 322 ok = checkInfo(testSetByIndex.getClass(), "ISetByIndex"); 323 System.out.println("OK = " + ok); 324 passed = passed && ok; 325 326 //---------------------------------------------------------------------- 327 328 // TODO: please uncomment/update after 8155013 fix 329 /* 330 IGetArray testGetArray = new IGetArray() { 331 332 private final double x[] = {X, X}; 333 334 @BeanProperty( 335 description = DESCRIPTION, 336 bound = BOUND, 337 expert = EXPERT, 338 hidden = HIDDEN, 339 preferred = PREFERRED, 340 required = REQUIRED, 341 visualUpdate = UPDATE, 342 enumerationValues = {V_NAME}) 343 @Override 344 public double[] getX() { return x; } 345 346 public void addPropertyChangeListener(PropertyChangeListener l) {} 347 public void removePropertyChangeListener(PropertyChangeListener l) {} 348 }; 349 ok = checkInfo(testGetArray.getClass(), "IGetArray"); 350 System.out.println("OK = " + ok); 351 passed = passed && ok; 352 */ 353 354 //---------------------------------------------------------------------- 355 356 // TODO: please uncomment/update after 8155013 fix 357 /* 358 ISetArray testSetArray = new ISetArray() { 359 360 private double x[]; 361 362 @BeanProperty( 363 description = DESCRIPTION, 364 bound = BOUND, 365 expert = EXPERT, 366 hidden = HIDDEN, 367 preferred = PREFERRED, 368 required = REQUIRED, 369 visualUpdate = UPDATE, 370 enumerationValues = {V_NAME}) 371 @Override 372 public void setX(double a[]) { x = Arrays.copyOf(a, a.length); } 373 374 public void addPropertyChangeListener(PropertyChangeListener l) {} 375 public void removePropertyChangeListener(PropertyChangeListener l) {} 376 }; 377 ok = checkInfo(testSetArray.getClass(), "ISetArray"); 378 System.out.println("OK = " + ok); 379 passed = passed && ok; 380 */ 381 382 //---------------------------------------------------------------------- 383 384 IGetBoth testGetBoth_1 = new IGetBoth() { 385 386 private final double x[] = {X, X}; 387 388 @BeanProperty( 389 description = DESCRIPTION, 390 bound = BOUND, 391 expert = EXPERT, 392 hidden = HIDDEN, 393 preferred = PREFERRED, 394 required = REQUIRED, 395 visualUpdate = UPDATE, 396 enumerationValues = {V_NAME}) 397 @Override 398 public double getX(int i) { return x[i]; } 399 @Override 400 public double[] getX() { return x; } 401 402 public void addPropertyChangeListener(PropertyChangeListener l) {} 403 public void removePropertyChangeListener(PropertyChangeListener l) {} 404 }; 405 ok = checkInfo(testGetBoth_1.getClass(), "IGetBoth-1"); 406 System.out.println("OK = " + ok); 407 passed = passed && ok; 408 409 // TODO: please uncomment/update after 8155013 fix 410 /* 411 IGetBoth testGetBoth_2 = new IGetBoth() { 412 413 private final double x[] = {X, X}; 414 415 @Override 416 public double getX(int i) { return x[i]; } 417 @BeanProperty( 418 description = DESCRIPTION, 419 bound = BOUND, 420 expert = EXPERT, 421 hidden = HIDDEN, 422 preferred = PREFERRED, 423 required = REQUIRED, 424 visualUpdate = UPDATE, 425 enumerationValues = {V_NAME}) 426 @Override 427 public double[] getX() { return x; } 428 429 public void addPropertyChangeListener(PropertyChangeListener l) {} 430 public void removePropertyChangeListener(PropertyChangeListener l) {} 431 }; 432 ok = checkInfo(testGetBoth_2.getClass(), "IGetBoth-2"); 433 System.out.println("OK = " + ok); 434 passed = passed && ok; 435 */ 436 437 // TODO: please uncomment/update after 8132732 fix 438 /* 439 IGetBoth testGetBoth_3 = new IGetBoth() { 440 441 private final double x[] = {X, X}; 442 443 @BeanProperty( 444 description = DESCRIPTION, 445 bound = BOUND, 446 expert = EXPERT, 447 hidden = HIDDEN, 448 preferred = PREFERRED, 449 required = REQUIRED, 450 visualUpdate = UPDATE, 451 enumerationValues = {V_NAME}) 452 @Override 453 public double getX(int i) { return x[i]; } 454 @BeanProperty( 455 description = DESCRIPTION_2, 456 bound = !BOUND, 457 expert = !EXPERT, 458 hidden = !HIDDEN, 459 preferred = !PREFERRED, 460 required = !REQUIRED, 461 visualUpdate = !UPDATE) 462 @Override 463 public double[] getX() { return x; } 464 465 public void addPropertyChangeListener(PropertyChangeListener l) {} 466 public void removePropertyChangeListener(PropertyChangeListener l) {} 467 }; 468 ok = checkInfo(testGetBoth_3.getClass(), "IGetBoth-3"); 469 System.out.println("OK = " + ok); 470 ok2 = checkAlternativeInfo(testGetBoth_3.getClass(), "IGetBoth-3"); 471 System.out.println("OK = " + ok2); 472 passed = passed && ok && ok2; 473 */ 474 475 //---------------------------------------------------------------------- 476 477 ISetBoth testSetBoth_1 = new ISetBoth() { 478 479 private double x[] = new double[3]; 480 481 @BeanProperty( 482 description = DESCRIPTION, 483 bound = BOUND, 484 expert = EXPERT, 485 hidden = HIDDEN, 486 preferred = PREFERRED, 487 required = REQUIRED, 488 visualUpdate = UPDATE, 489 enumerationValues = {V_NAME}) 490 @Override 491 public void setX(int i, double v) { x[i] = v; } 492 @Override 493 public void setX(double[] a) { x = Arrays.copyOf(a, a.length); } 494 495 public void addPropertyChangeListener(PropertyChangeListener l) {} 496 public void removePropertyChangeListener(PropertyChangeListener l) {} 497 }; 498 ok = checkInfo(testSetBoth_1.getClass(), "ISetBoth-1"); 499 System.out.println("OK = " + ok); 500 passed = passed && ok; 501 502 // TODO: please uncomment/update after 8155013 fix 503 /* 504 ISetBoth testSetBoth_2 = new ISetBoth() { 505 506 private double x[] = new double[3]; 507 508 @Override 509 public void setX(int i, double v) { x[i] = v; } 510 @BeanProperty( 511 description = DESCRIPTION, 512 bound = BOUND, 513 expert = EXPERT, 514 hidden = HIDDEN, 515 preferred = PREFERRED, 516 required = REQUIRED, 517 visualUpdate = UPDATE, 518 enumerationValues = {V_NAME}) 519 @Override 520 public void setX(double[] a) { x = Arrays.copyOf(a, a.length); } 521 522 public void addPropertyChangeListener(PropertyChangeListener l) {} 523 public void removePropertyChangeListener(PropertyChangeListener l) {} 524 }; 525 ok = checkInfo(testSetBoth_2.getClass(), "ISetBoth-2"); 526 System.out.println("OK = " + ok); 527 passed = passed && ok; 528 */ 529 530 // TODO: please uncomment/update after 8132732 fix 531 /* 532 ISetBoth testSetBoth_3 = new ISetBoth() { 533 534 private double x[] = {X, X}; 535 536 @BeanProperty( 537 description = DESCRIPTION, 538 bound = BOUND, 539 expert = EXPERT, 540 hidden = HIDDEN, 541 preferred = PREFERRED, 542 required = REQUIRED, 543 visualUpdate = UPDATE, 544 enumerationValues = {V_NAME}) 545 @Override 546 public void setX(int i, double v) { x[i] = v; } 547 @BeanProperty( 548 description = DESCRIPTION_2, 549 bound = !BOUND, 550 expert = !EXPERT, 551 hidden = !HIDDEN, 552 preferred = !PREFERRED, 553 required = !REQUIRED, 554 visualUpdate = !UPDATE) 555 @Override 556 public void setX(double[] a) { x = Arrays.copyOf(a, a.length); } 557 558 public void addPropertyChangeListener(PropertyChangeListener l) {} 559 public void removePropertyChangeListener(PropertyChangeListener l) {} 560 }; 561 ok = checkInfo(testSetBoth_3.getClass(), "ISetBoth-3"); 562 System.out.println("OK = " + ok); 563 ok2 = checkAlternativeInfo(testSetBoth_3.getClass(), "ISetBoth-3"); 564 System.out.println("OK = " + ok2); 565 passed = passed && ok && ok2; 566 */ 567 568 //---------------------------------------------------------------------- 569 570 IGetSet testGetSet_1 = new IGetSet() { 571 572 private double x; 573 574 @BeanProperty( 575 description = DESCRIPTION, 576 bound = BOUND, 577 expert = EXPERT, 578 hidden = HIDDEN, 579 preferred = PREFERRED, 580 required = REQUIRED, 581 visualUpdate = UPDATE, 582 enumerationValues = {V_NAME}) 583 @Override 584 public double getX() { return x; } 585 @Override 586 public void setX(double v) { x = v; } 587 588 public void addPropertyChangeListener(PropertyChangeListener l) {} 589 public void removePropertyChangeListener(PropertyChangeListener l) {} 590 }; 591 ok = checkInfo(testGetSet_1.getClass(), "IGetSet-1"); 592 System.out.println("OK = " + ok); 593 passed = passed && ok; 594 595 596 IGetSet testGetSet_2 = new IGetSet() { 597 598 private double x; 599 600 @Override 601 public double getX() { return x; } 602 @BeanProperty( 603 description = DESCRIPTION, 604 bound = BOUND, 605 expert = EXPERT, 606 hidden = HIDDEN, 607 preferred = PREFERRED, 608 required = REQUIRED, 609 visualUpdate = UPDATE, 610 enumerationValues = {V_NAME}) 611 @Override 612 public void setX(double v) { x = v; } 613 614 public void addPropertyChangeListener(PropertyChangeListener l) {} 615 public void removePropertyChangeListener(PropertyChangeListener l) {} 616 }; 617 ok = checkInfo(testGetSet_2.getClass(), "IGetSet-2"); 618 System.out.println("OK = " + ok); 619 passed = passed && ok; 620 621 // TODO: please uncomment/update after 8132973 fix 622 /* 623 IGetSet testGetSet_3 = new IGetSet() { 624 625 private double x; 626 627 @Override 628 @BeanProperty( 629 description = DESCRIPTION, 630 bound = BOUND, 631 expert = EXPERT, 632 hidden = HIDDEN, 633 preferred = PREFERRED, 634 required = REQUIRED, 635 visualUpdate = UPDATE, 636 enumerationValues = {V_NAME}) 637 public double getX() { return x; } 638 @BeanProperty( 639 description = DESCRIPTION_2, 640 bound = !BOUND, 641 expert = !EXPERT, 642 hidden = !HIDDEN, 643 preferred = !PREFERRED, 644 required = !REQUIRED, 645 visualUpdate = !UPDATE) 646 @Override 647 public void setX(double v) { x = v; } 648 649 public void addPropertyChangeListener(PropertyChangeListener l) {} 650 public void removePropertyChangeListener(PropertyChangeListener l) {} 651 }; 652 ok = checkInfo(testGetSet_3.getClass(), "IGetSet-3"); 653 System.out.println("OK = " + ok); 654 ok2 = checkAlternativeInfo(testGetSet_3.getClass(), "IGetSet-3"); 655 System.out.println("OK = " + ok2); 656 passed = passed && ok && ok2; 657 */ 658 659 //---------------------------------------------------------------------- 660 661 IGetSetByIndex testGetSetByIndex_1 = new IGetSetByIndex() { 662 663 private final double x[] = {X, X}; 664 665 @BeanProperty( 666 description = DESCRIPTION, 667 bound = BOUND, 668 expert = EXPERT, 669 hidden = HIDDEN, 670 preferred = PREFERRED, 671 required = REQUIRED, 672 visualUpdate = UPDATE, 673 enumerationValues = {V_NAME}) 674 @Override 675 public double getX(int i) { return x[i]; } 676 @Override 677 public void setX(int i, double v) { x[i] = v; } 678 679 public void addPropertyChangeListener(PropertyChangeListener l) {} 680 public void removePropertyChangeListener(PropertyChangeListener l) {} 681 }; 682 ok = checkInfo(testGetSetByIndex_1.getClass(), "IGetSetByIndex-1"); 683 System.out.println("OK = " + ok); 684 passed = passed && ok; 685 686 687 IGetSetByIndex testGetSetByIndex_2 = new IGetSetByIndex() { 688 689 private final double x[] = {X, X}; 690 691 @Override 692 public double getX(int i) { return x[i]; } 693 @BeanProperty( 694 description = DESCRIPTION, 695 bound = BOUND, 696 expert = EXPERT, 697 hidden = HIDDEN, 698 preferred = PREFERRED, 699 required = REQUIRED, 700 visualUpdate = UPDATE, 701 enumerationValues = {V_NAME}) 702 @Override 703 public void setX(int i, double v) { x[i] = v; } 704 705 public void addPropertyChangeListener(PropertyChangeListener l) {} 706 public void removePropertyChangeListener(PropertyChangeListener l) {} 707 }; 708 ok = checkInfo(testGetSetByIndex_2.getClass(), "IGetSetByIndex-2"); 709 System.out.println("OK = " + ok); 710 passed = passed && ok; 711 712 // TODO: please uncomment/update after 8132973 fix 713 /* 714 IGetSetByIndex testGetSetByIndex_3 = new IGetSetByIndex() { 715 716 private double x[] = {X, X}; 717 718 @BeanProperty( 719 description = DESCRIPTION, 720 bound = BOUND, 721 expert = EXPERT, 722 hidden = HIDDEN, 723 preferred = PREFERRED, 724 required = REQUIRED, 725 visualUpdate = UPDATE, 726 enumerationValues = {V_NAME}) 727 @Override 728 public double getX(int i) { 729 return x[i]; 730 } 731 @BeanProperty( 732 description = DESCRIPTION_2, 733 bound = !BOUND, 734 expert = !EXPERT, 735 hidden = !HIDDEN, 736 preferred = !PREFERRED, 737 required = !REQUIRED, 738 visualUpdate = !UPDATE) 739 @Override 740 public void setX(int i, double v) { 741 x[i] = v; 742 } 743 744 public void addPropertyChangeListener(PropertyChangeListener l) {} 745 public void removePropertyChangeListener(PropertyChangeListener l) {} 746 }; 747 ok = checkInfo(testGetSetByIndex_3.getClass(), "IGetSetByIndex-3"); 748 System.out.println("OK = " + ok); 749 ok2 = checkAlternativeInfo( 750 testGetSetByIndex_3.getClass(), "IGetSetByIndex-3"); 751 System.out.println("OK = " + ok2); 752 passed = passed && ok && ok2; 753 */ 754 755 //---------------------------------------------------------------------- 756 757 // TODO: please uncomment/update after 8155013 fix 758 /* 759 IGetSetBoth testGetSetBoth_1 = new IGetSetBoth() { 760 761 private double x[] = {X, X}; 762 763 @Override 764 public double getX(int i) { return x[i]; } 765 @BeanProperty( 766 description = DESCRIPTION, 767 bound = BOUND, 768 expert = EXPERT, 769 hidden = HIDDEN, 770 preferred = PREFERRED, 771 required = REQUIRED, 772 visualUpdate = UPDATE, 773 enumerationValues = {V_NAME}) 774 @Override 775 public double[] getX() { return x; } 776 @Override 777 public void setX(int i, double v) { x[i] = v; } 778 @Override 779 public void setX(double[] a) { x = Arrays.copyOf(a, a.length); } 780 781 public void addPropertyChangeListener(PropertyChangeListener l) {} 782 public void removePropertyChangeListener(PropertyChangeListener l) {} 783 }; 784 ok = checkInfo(testGetSetBoth_1.getClass(), "IGetSetBoth-1"); 785 System.out.println("OK = " + ok); 786 passed = passed && ok; 787 */ 788 789 // TODO: please uncomment/update after 8155013 fix 790 /* 791 IGetSetBoth testGetSetBoth_2 = new IGetSetBoth() { 792 793 private double x[] = {X, X}; 794 795 @Override 796 public double getX(int i) { return x[i]; } 797 @Override 798 public double[] getX() { return x; } 799 @Override 800 public void setX(int i, double v) { x[i] = v; } 801 @BeanProperty( 802 description = DESCRIPTION, 803 bound = BOUND, 804 expert = EXPERT, 805 hidden = HIDDEN, 806 preferred = PREFERRED, 807 required = REQUIRED, 808 visualUpdate = UPDATE, 809 enumerationValues = {V_NAME}) 810 @Override 811 public void setX(double[] a) { x = Arrays.copyOf(a, a.length); } 812 813 public void addPropertyChangeListener(PropertyChangeListener l) {} 814 public void removePropertyChangeListener(PropertyChangeListener l) {} 815 }; 816 ok = checkInfo(testGetSetBoth_2.getClass(), "IGetSetBoth-2"); 817 System.out.println("OK = " + ok); 818 passed = passed && ok; 819 */ 820 821 // TODO: please uncomment/update after 8132973 fix 822 /* 823 IGetSetBoth testGetSetBoth_3 = new IGetSetBoth() { 824 825 private double x[] = {X, X}; 826 827 @BeanProperty( 828 description = DESCRIPTION, 829 bound = BOUND, 830 expert = EXPERT, 831 hidden = HIDDEN, 832 preferred = PREFERRED, 833 required = REQUIRED, 834 visualUpdate = UPDATE, 835 enumerationValues = {V_NAME}) 836 @Override 837 public double getX(int i) { return x[i]; } 838 @Override 839 public double[] getX() { return x; } 840 @Override 841 public void setX(int i, double v) { x[i] = v; } 842 @BeanProperty( 843 description = DESCRIPTION_2, 844 bound = !BOUND, 845 expert = !EXPERT, 846 hidden = !HIDDEN, 847 preferred = !PREFERRED, 848 required = !REQUIRED, 849 visualUpdate = !UPDATE) 850 @Override 851 public void setX(double[] a) { x = Arrays.copyOf(a, a.length); } 852 853 public void addPropertyChangeListener(PropertyChangeListener l) {} 854 public void removePropertyChangeListener(PropertyChangeListener l) {} 855 }; 856 ok = checkInfo(testGetSetBoth_3.getClass(), "IGetSetBoth-3"); 857 System.out.println("OK = " + ok); 858 ok2 = checkAlternativeInfo( 859 testGetSetBoth_3.getClass(), "IGetSetBoth-3"); 860 System.out.println("OK = " + ok2); 861 passed = passed && ok && ok2; 862 */ 863 864 if (!passed) { throw new RuntimeException("test failed"); } 865 System.out.println("\ntest passed"); 866 } 867 }