< prev index next >

test/java/beans/Introspector/AnonymousClassBeanPropertyTest.java

Print this page




  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 


  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()); }


 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 }


  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 8154958
  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     public interface IPublic {
  66         double getX();
  67     }
  68 
  69     private interface IGet {
  70         double getX();
  71     }
  72 
  73     private interface ISet {
  74         void setX(double v);
  75     }
  76 
  77     private interface IGetByIndex {
  78         double getX(int i);
  79     }
  80 
  81     private interface ISetByIndex {
  82         void setX(int i, double v);
  83     }
  84 
  85     private interface IGetArray {
  86         double[] getX();
  87     }
  88 


 100         void setX(double a[]);
 101     }
 102 
 103     private interface IGetSet {
 104         double getX();
 105         void setX(double v);
 106     }
 107 
 108     private interface IGetSetByIndex {
 109         double getX(int i);
 110         void setX(int i, double v);
 111     }
 112 
 113     private interface IGetSetBoth {
 114         double   getX(int i);
 115         double[] getX();
 116         void setX(int i, double v);
 117         void setX(double a[]);
 118     }
 119 
 120     private interface IIs {
 121         boolean isX();
 122     }
 123 
 124 
 125     // ---------- checks ----------
 126 
 127     private static boolean check(String what, boolean v, boolean ref) {
 128 
 129         boolean ok = (v == ref);
 130         if (!ok) { System.out.println(
 131             "invalid " + what + ": " + v + ", expected: " + ref); }
 132         return ok;
 133     }
 134 
 135     private static boolean checkInfo(Class<?> c, String what, boolean checkVals) {
 136 
 137         BeanInfo i;
 138         try { i = Introspector.getBeanInfo(c, Object.class); }
 139         catch (IntrospectionException e) { throw new RuntimeException(e); }
 140 
 141         System.out.println("\nchecking info for " + what);
 142 
 143         PropertyDescriptor descriptors[] = i.getPropertyDescriptors();
 144         int nd = descriptors.length;
 145         if (nd != 1) {
 146             System.out.println("invalid number of descriptors: " + nd);
 147             return false;
 148         }
 149 
 150         PropertyDescriptor d = descriptors[0];
 151 
 152         String descr = d.getShortDescription();
 153         boolean ok = descr.equals(DESCRIPTION);
 154         if (!ok) { System.out.println("invalid description: " + descr +
 155                 ", expected: " + DESCRIPTION); }
 156 
 157         ok &= check("isBound",  d.isBound(),  BOUND);
 158         ok &= check("isExpert", d.isExpert(), EXPERT);
 159         ok &= check("isHidden", d.isHidden(), HIDDEN);
 160         ok &= check("isPreferred", d.isPreferred(), PREFERRED);
 161         ok &= check("required", (boolean) d.getValue("required"), REQUIRED);
 162         ok &= check("visualUpdate",
 163             (boolean) d.getValue("visualUpdate"), UPDATE);
 164 
 165         if (!checkVals) { return ok; }
 166 
 167         Object vals[] = (Object[]) d.getValue("enumerationValues");
 168         if (vals == null) {
 169             System.out.println("null enumerationValues");
 170             return false;
 171         }
 172 
 173         if (vals.length == 0) {
 174             System.out.println("empty enumerationValues");
 175             return false;
 176         }
 177 
 178         boolean okVals = (
 179             (vals.length == 3) &&
 180              vals[0].toString().equals(V_SHORT) &&
 181              vals[1].toString().equals(V)       &&
 182              vals[2].toString().equals(V_NAME));
 183 
 184         if (!okVals) {
 185             System.out.println("invalid enumerationValues:");
 186             for (Object v: vals) { System.out.println(v.toString()); }


 203             System.out.println("invalid number of descriptors: " + nd);
 204             return false;
 205         }
 206 
 207         PropertyDescriptor d = descriptors[0];
 208 
 209         String descr = d.getShortDescription();
 210         boolean ok = descr.equals(DESCRIPTION_2);
 211         if (!ok) { System.out.println("invalid alternative description: " +
 212             descr + ", expected: " + DESCRIPTION_2); }
 213 
 214         ok &= check("isBound",  d.isBound(),  !BOUND);
 215         ok &= check("isExpert", d.isExpert(), !EXPERT);
 216         ok &= check("isHidden", d.isHidden(), !HIDDEN);
 217         ok &= check("isPreferred", d.isPreferred(), !PREFERRED);
 218         ok &= check("required", (boolean) d.getValue("required"), !REQUIRED);
 219         ok &= check("visualUpdate",
 220             (boolean) d.getValue("visualUpdate"), !UPDATE);
 221 
 222         Object vals[] = (Object[]) d.getValue("enumerationValues");
 223         if (vals != null && vals.length > 0) {
 224             System.out.println("non-empty enumerationValues:");
 225             for (Object v: vals) { System.out.print(v.toString()); }
 226             System.out.println();
 227             return false;
 228         }
 229 
 230         return ok;
 231     }
 232 
 233 
 234 
 235     // ---------- run tests ----------
 236 
 237     public static void main(String[] args) {
 238 
 239         boolean passed = true, ok, ok2;
 240 
 241         //----------------------------------------------------------------------
 242 
 243         // TODO: please uncomment/update after 8154958 fix
 244         /*
 245         IPublic testPublic = new IPublic() {
 246             @BeanProperty(
 247                 description  = DESCRIPTION,
 248                 bound        = BOUND,
 249                 expert       = EXPERT,
 250                 hidden       = HIDDEN,
 251                 preferred    = PREFERRED,
 252                 required     = REQUIRED,
 253                 visualUpdate = UPDATE,
 254                 enumerationValues = {V_NAME})
 255             @Override
 256             public double getX() { return X; }
 257 
 258             public void addPropertyChangeListener(PropertyChangeListener l)    {}
 259             public void removePropertyChangeListener(PropertyChangeListener l) {}
 260         };
 261         ok = checkInfo(testPublic.getClass(), "IPublic", true);
 262         System.out.println("OK = " + ok);
 263         passed = passed && ok;
 264         */
 265 
 266         //----------------------------------------------------------------------
 267 
 268         IGet testGet = new IGet() {
 269             @BeanProperty(
 270                 description  = DESCRIPTION,
 271                 bound        = BOUND,
 272                 expert       = EXPERT,
 273                 hidden       = HIDDEN,
 274                 preferred    = PREFERRED,
 275                 required     = REQUIRED,
 276                 visualUpdate = UPDATE,
 277                 enumerationValues = {V_NAME})
 278             @Override
 279             public double getX() { return X; }
 280 
 281             public void addPropertyChangeListener(PropertyChangeListener l)    {}
 282             public void removePropertyChangeListener(PropertyChangeListener l) {}
 283         };
 284         ok = checkInfo(testGet.getClass(), "IGet", true);
 285         System.out.println("OK = " + ok);
 286         passed = passed && ok;
 287 
 288         //----------------------------------------------------------------------
 289 
 290         ISet testSet = new ISet() {
 291 
 292             private double x;
 293 
 294             @BeanProperty(
 295                 description  = DESCRIPTION,
 296                 bound        = BOUND,
 297                 expert       = EXPERT,
 298                 hidden       = HIDDEN,
 299                 preferred    = PREFERRED,
 300                 required     = REQUIRED,
 301                 visualUpdate = UPDATE,
 302                 enumerationValues = {V_NAME})
 303             @Override
 304             public void setX(double v) { x = v; }
 305 
 306             public void addPropertyChangeListener(PropertyChangeListener l)    {}
 307             public void removePropertyChangeListener(PropertyChangeListener l) {}
 308         };
 309         ok = checkInfo(testSet.getClass(), "ISet", true);
 310         System.out.println("OK = " + ok);
 311         passed = passed && ok;
 312 
 313         //----------------------------------------------------------------------
 314 
 315         IGetByIndex testGetByIndex = new IGetByIndex() {
 316 
 317             private final double x[] = {X, X};
 318 
 319             @BeanProperty(
 320                 description  = DESCRIPTION,
 321                 bound        = BOUND,
 322                 expert       = EXPERT,
 323                 hidden       = HIDDEN,
 324                 preferred    = PREFERRED,
 325                 required     = REQUIRED,
 326                 visualUpdate = UPDATE,
 327                 enumerationValues = {V_NAME})
 328             @Override
 329             public double getX(int i) { return x[i]; }
 330 
 331             public void addPropertyChangeListener(PropertyChangeListener l)    {}
 332             public void removePropertyChangeListener(PropertyChangeListener l) {}
 333         };
 334         ok = checkInfo(testGetByIndex.getClass(), "IGetByIndex", true);
 335         System.out.println("OK = " + ok);
 336         passed = passed && ok;
 337 
 338         //----------------------------------------------------------------------
 339 
 340         ISetByIndex testSetByIndex = new ISetByIndex() {
 341 
 342             private final double x[] = {X, X, X};
 343 
 344             @BeanProperty(
 345                 description  = DESCRIPTION,
 346                 bound        = BOUND,
 347                 expert       = EXPERT,
 348                 hidden       = HIDDEN,
 349                 preferred    = PREFERRED,
 350                 required     = REQUIRED,
 351                 visualUpdate = UPDATE,
 352                 enumerationValues = {V_NAME})
 353             @Override
 354             public void setX(int i, double v) { x[i] = v; }
 355 
 356             public void addPropertyChangeListener(PropertyChangeListener l)    {}
 357             public void removePropertyChangeListener(PropertyChangeListener l) {}
 358         };
 359         ok = checkInfo(testSetByIndex.getClass(), "ISetByIndex", true);
 360         System.out.println("OK = " + ok);
 361         passed = passed && ok;
 362 
 363         //----------------------------------------------------------------------
 364 
 365         // TODO: please uncomment/update after 8155013 fix
 366         /*
 367         IGetArray testGetArray = new IGetArray() {
 368 
 369             private final double x[] = {X, X};
 370 
 371             @BeanProperty(
 372                 description  = DESCRIPTION,
 373                 bound        = BOUND,
 374                 expert       = EXPERT,
 375                 hidden       = HIDDEN,
 376                 preferred    = PREFERRED,
 377                 required     = REQUIRED,
 378                 visualUpdate = UPDATE,
 379                 enumerationValues = {V_NAME})
 380             @Override
 381             public double[] getX() { return x; }
 382 
 383             public void addPropertyChangeListener(PropertyChangeListener l)    {}
 384             public void removePropertyChangeListener(PropertyChangeListener l) {}
 385         };
 386         ok = checkInfo(testGetArray.getClass(), "IGetArray", true);
 387         System.out.println("OK = " + ok);
 388         passed = passed && ok;
 389         */
 390 
 391         //----------------------------------------------------------------------
 392 
 393         // TODO: please uncomment/update after 8155013 fix
 394         /*
 395         ISetArray testSetArray = new ISetArray() {
 396 
 397             private double x[];
 398 
 399             @BeanProperty(
 400                 description  = DESCRIPTION,
 401                 bound        = BOUND,
 402                 expert       = EXPERT,
 403                 hidden       = HIDDEN,
 404                 preferred    = PREFERRED,
 405                 required     = REQUIRED,
 406                 visualUpdate = UPDATE,
 407                 enumerationValues = {V_NAME})
 408             @Override
 409             public void setX(double a[]) { x = Arrays.copyOf(a, a.length); }
 410 
 411             public void addPropertyChangeListener(PropertyChangeListener l)    {}
 412             public void removePropertyChangeListener(PropertyChangeListener l) {}
 413         };
 414         ok = checkInfo(testSetArray.getClass(), "ISetArray", true);
 415         System.out.println("OK = " + ok);
 416         passed = passed && ok;
 417         */
 418 
 419         //----------------------------------------------------------------------
 420 
 421         IGetBoth testGetBoth_1 = new IGetBoth() {
 422 
 423             private final double x[] = {X, X};
 424 
 425             @BeanProperty(
 426                 description  = DESCRIPTION,
 427                 bound        = BOUND,
 428                 expert       = EXPERT,
 429                 hidden       = HIDDEN,
 430                 preferred    = PREFERRED,
 431                 required     = REQUIRED,
 432                 visualUpdate = UPDATE,
 433                 enumerationValues = {V_NAME})
 434             @Override
 435             public double getX(int i) { return x[i]; }
 436             @Override
 437             public double[] getX() { return x; }
 438 
 439             public void addPropertyChangeListener(PropertyChangeListener l)    {}
 440             public void removePropertyChangeListener(PropertyChangeListener l) {}
 441         };
 442         ok = checkInfo(testGetBoth_1.getClass(), "IGetBoth-1", true);
 443         System.out.println("OK = " + ok);
 444         passed = passed && ok;
 445 
 446         // TODO: please uncomment/update after 8155013 fix
 447         /*
 448         IGetBoth testGetBoth_2 = new IGetBoth() {
 449 
 450             private final double x[] = {X, X};
 451 
 452             @Override
 453             public double getX(int i) { return x[i]; }
 454             @BeanProperty(
 455                 description  = DESCRIPTION,
 456                 bound        = BOUND,
 457                 expert       = EXPERT,
 458                 hidden       = HIDDEN,
 459                 preferred    = PREFERRED,
 460                 required     = REQUIRED,
 461                 visualUpdate = UPDATE,
 462                 enumerationValues = {V_NAME})
 463             @Override
 464             public double[] getX() { return x; }
 465 
 466             public void addPropertyChangeListener(PropertyChangeListener l)    {}
 467             public void removePropertyChangeListener(PropertyChangeListener l) {}
 468         };
 469         ok = checkInfo(testGetBoth_2.getClass(), "IGetBoth-2", true);
 470         System.out.println("OK = " + ok);
 471         passed = passed && ok;
 472         */
 473 
 474         // TODO: please uncomment/update after 8132732 fix
 475         /*
 476         IGetBoth testGetBoth_3 = new IGetBoth() {
 477 
 478             private final double x[] = {X, X};
 479 
 480             @BeanProperty(
 481                 description  = DESCRIPTION,
 482                 bound        = BOUND,
 483                 expert       = EXPERT,
 484                 hidden       = HIDDEN,
 485                 preferred    = PREFERRED,
 486                 required     = REQUIRED,
 487                 visualUpdate = UPDATE,
 488                 enumerationValues = {V_NAME})
 489             @Override
 490             public double getX(int i) { return x[i]; }
 491             @BeanProperty(
 492                 description  = DESCRIPTION_2,
 493                 bound        = !BOUND,
 494                 expert       = !EXPERT,
 495                 hidden       = !HIDDEN,
 496                 preferred    = !PREFERRED,
 497                 required     = !REQUIRED,
 498                 visualUpdate = !UPDATE)
 499             @Override
 500             public double[] getX() { return x; }
 501 
 502             public void addPropertyChangeListener(PropertyChangeListener l)    {}
 503             public void removePropertyChangeListener(PropertyChangeListener l) {}
 504         };
 505         ok = checkInfo(testGetBoth_3.getClass(), "IGetBoth-3", true);
 506         System.out.println("OK = " + ok);
 507         ok2 = checkAlternativeInfo(testGetBoth_3.getClass(), "IGetBoth-3");
 508         System.out.println("OK = " + ok2);
 509         passed = passed && (ok || ok2);
 510         */
 511 
 512         //----------------------------------------------------------------------
 513 
 514         ISetBoth testSetBoth_1 = new ISetBoth() {
 515 
 516             private double x[] = new double[3];
 517 
 518             @BeanProperty(
 519                 description  = DESCRIPTION,
 520                 bound        = BOUND,
 521                 expert       = EXPERT,
 522                 hidden       = HIDDEN,
 523                 preferred    = PREFERRED,
 524                 required     = REQUIRED,
 525                 visualUpdate = UPDATE,
 526                 enumerationValues = {V_NAME})
 527             @Override
 528             public void setX(int i, double v) { x[i] = v; }
 529             @Override
 530             public void setX(double[] a) { x = Arrays.copyOf(a, a.length); }
 531 
 532             public void addPropertyChangeListener(PropertyChangeListener l)    {}
 533             public void removePropertyChangeListener(PropertyChangeListener l) {}
 534         };
 535         ok = checkInfo(testSetBoth_1.getClass(), "ISetBoth-1", true);
 536         System.out.println("OK = " + ok);
 537         passed = passed && ok;
 538 
 539         // TODO: please uncomment/update after 8155013 fix
 540         /*
 541         ISetBoth testSetBoth_2 = new ISetBoth() {
 542 
 543             private double x[] = new double[3];
 544 
 545             @Override
 546             public void setX(int i, double v) { x[i] = v; }
 547             @BeanProperty(
 548                 description  = DESCRIPTION,
 549                 bound        = BOUND,
 550                 expert       = EXPERT,
 551                 hidden       = HIDDEN,
 552                 preferred    = PREFERRED,
 553                 required     = REQUIRED,
 554                 visualUpdate = UPDATE,
 555                 enumerationValues = {V_NAME})
 556             @Override
 557             public void setX(double[] a) { x = Arrays.copyOf(a, a.length); }
 558 
 559             public void addPropertyChangeListener(PropertyChangeListener l)    {}
 560             public void removePropertyChangeListener(PropertyChangeListener l) {}
 561         };
 562         ok = checkInfo(testSetBoth_2.getClass(), "ISetBoth-2", true);
 563         System.out.println("OK = " + ok);
 564         passed = passed && ok;
 565         */
 566 
 567         // TODO: please uncomment/update after 8132732 fix
 568         /*
 569         ISetBoth testSetBoth_3 = new ISetBoth() {
 570 
 571             private double x[] = {X, X};
 572 
 573             @BeanProperty(
 574                 description  = DESCRIPTION,
 575                 bound        = BOUND,
 576                 expert       = EXPERT,
 577                 hidden       = HIDDEN,
 578                 preferred    = PREFERRED,
 579                 required     = REQUIRED,
 580                 visualUpdate = UPDATE,
 581                 enumerationValues = {V_NAME})
 582             @Override
 583             public void setX(int i, double v) { x[i] = v; }
 584             @BeanProperty(
 585                 description  = DESCRIPTION_2,
 586                 bound        = !BOUND,
 587                 expert       = !EXPERT,
 588                 hidden       = !HIDDEN,
 589                 preferred    = !PREFERRED,
 590                 required     = !REQUIRED,
 591                 visualUpdate = !UPDATE)
 592             @Override
 593             public void setX(double[] a) { x = Arrays.copyOf(a, a.length); }
 594 
 595             public void addPropertyChangeListener(PropertyChangeListener l)    {}
 596             public void removePropertyChangeListener(PropertyChangeListener l) {}
 597         };
 598         ok = checkInfo(testSetBoth_3.getClass(), "ISetBoth-3", true);
 599         System.out.println("OK = " + ok);
 600         ok2 = checkAlternativeInfo(testSetBoth_3.getClass(), "ISetBoth-3");
 601         System.out.println("OK = " + ok2);
 602         passed = passed && (ok || ok2);
 603         */
 604 
 605         //----------------------------------------------------------------------
 606 
 607         IGetSet testGetSet_1 = new IGetSet() {
 608 
 609             private double x;
 610 
 611             @BeanProperty(
 612                 description  = DESCRIPTION,
 613                 bound        = BOUND,
 614                 expert       = EXPERT,
 615                 hidden       = HIDDEN,
 616                 preferred    = PREFERRED,
 617                 required     = REQUIRED,
 618                 visualUpdate = UPDATE,
 619                 enumerationValues = {V_NAME})
 620             @Override
 621             public double getX() { return x; }
 622             @Override
 623             public void setX(double v) { x = v; }
 624 
 625             public void addPropertyChangeListener(PropertyChangeListener l)    {}
 626             public void removePropertyChangeListener(PropertyChangeListener l) {}
 627         };
 628         ok = checkInfo(testGetSet_1.getClass(), "IGetSet-1", true);
 629         System.out.println("OK = " + ok);
 630         passed = passed && ok;
 631 
 632 
 633         IGetSet testGetSet_2 = new IGetSet() {
 634 
 635             private double x;
 636 
 637             @Override
 638             public double getX() { return x; }
 639             @BeanProperty(
 640                 description  = DESCRIPTION,
 641                 bound        = BOUND,
 642                 expert       = EXPERT,
 643                 hidden       = HIDDEN,
 644                 preferred    = PREFERRED,
 645                 required     = REQUIRED,
 646                 visualUpdate = UPDATE,
 647                 enumerationValues = {V_NAME})
 648             @Override
 649             public void setX(double v) { x = v; }
 650 
 651             public void addPropertyChangeListener(PropertyChangeListener l)    {}
 652             public void removePropertyChangeListener(PropertyChangeListener l) {}
 653         };
 654         ok = checkInfo(testGetSet_2.getClass(), "IGetSet-2", true);
 655         System.out.println("OK = " + ok);
 656         passed = passed && ok;
 657 
 658         // TODO: please uncomment/update after 8132973 fix
 659         /*
 660         IGetSet testGetSet_3 = new IGetSet() {
 661 
 662             private double x;
 663 
 664             @Override
 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             public double getX() { return x; }
 675             @BeanProperty(
 676                 description  = DESCRIPTION_2,
 677                 bound        = !BOUND,
 678                 expert       = !EXPERT,
 679                 hidden       = !HIDDEN,
 680                 preferred    = !PREFERRED,
 681                 required     = !REQUIRED,
 682                 visualUpdate = !UPDATE)
 683             @Override
 684             public void setX(double v) { x = v; }
 685 
 686             public void addPropertyChangeListener(PropertyChangeListener l)    {}
 687             public void removePropertyChangeListener(PropertyChangeListener l) {}
 688         };
 689         ok = checkInfo(testGetSet_3.getClass(), "IGetSet-3", true);
 690         System.out.println("OK = " + ok);
 691         ok2 = checkAlternativeInfo(testGetSet_3.getClass(), "IGetSet-3");
 692         System.out.println("OK = " + ok2);
 693         passed = passed && (ok || ok2);
 694         */
 695 
 696         //----------------------------------------------------------------------
 697 
 698         IGetSetByIndex testGetSetByIndex_1 = new IGetSetByIndex() {
 699 
 700             private final double x[] = {X, X};
 701 
 702             @BeanProperty(
 703                 description  = DESCRIPTION,
 704                 bound        = BOUND,
 705                 expert       = EXPERT,
 706                 hidden       = HIDDEN,
 707                 preferred    = PREFERRED,
 708                 required     = REQUIRED,
 709                 visualUpdate = UPDATE,
 710                 enumerationValues = {V_NAME})
 711             @Override
 712             public double getX(int i) { return x[i]; }
 713             @Override
 714             public void setX(int i, double v) { x[i] = v; }
 715 
 716             public void addPropertyChangeListener(PropertyChangeListener l)    {}
 717             public void removePropertyChangeListener(PropertyChangeListener l) {}
 718         };
 719         ok = checkInfo(testGetSetByIndex_1.getClass(), "IGetSetByIndex-1", true);
 720         System.out.println("OK = " + ok);
 721         passed = passed && ok;
 722 
 723 
 724         IGetSetByIndex testGetSetByIndex_2 = new IGetSetByIndex() {
 725 
 726             private final double x[] = {X, X};
 727 
 728             @Override
 729             public double getX(int i) { return x[i]; }
 730             @BeanProperty(
 731                 description  = DESCRIPTION,
 732                 bound        = BOUND,
 733                 expert       = EXPERT,
 734                 hidden       = HIDDEN,
 735                 preferred    = PREFERRED,
 736                 required     = REQUIRED,
 737                 visualUpdate = UPDATE,
 738                 enumerationValues = {V_NAME})
 739             @Override
 740             public void setX(int i, double v) { x[i] = v; }
 741 
 742             public void addPropertyChangeListener(PropertyChangeListener l)    {}
 743             public void removePropertyChangeListener(PropertyChangeListener l) {}
 744         };
 745         ok = checkInfo(testGetSetByIndex_2.getClass(), "IGetSetByIndex-2", true);
 746         System.out.println("OK = " + ok);
 747         passed = passed && ok;
 748 
 749         // TODO: please uncomment/update after 8132973 fix
 750         /*
 751         IGetSetByIndex testGetSetByIndex_3 = new IGetSetByIndex() {
 752 
 753             private double x[] = {X, X};
 754 
 755             @BeanProperty(
 756                 description  = DESCRIPTION,
 757                 bound        = BOUND,
 758                 expert       = EXPERT,
 759                 hidden       = HIDDEN,
 760                 preferred    = PREFERRED,
 761                 required     = REQUIRED,
 762                 visualUpdate = UPDATE,
 763                 enumerationValues = {V_NAME})
 764             @Override
 765             public double getX(int i) {
 766                 return x[i];
 767             }
 768             @BeanProperty(
 769                 description  = DESCRIPTION_2,
 770                 bound        = !BOUND,
 771                 expert       = !EXPERT,
 772                 hidden       = !HIDDEN,
 773                 preferred    = !PREFERRED,
 774                 required     = !REQUIRED,
 775                 visualUpdate = !UPDATE)
 776             @Override
 777             public void setX(int i, double v) {
 778                 x[i] = v;
 779             }
 780 
 781             public void addPropertyChangeListener(PropertyChangeListener l)    {}
 782             public void removePropertyChangeListener(PropertyChangeListener l) {}
 783         };
 784         ok = checkInfo(testGetSetByIndex_3.getClass(), "IGetSetByIndex-3", true);
 785         System.out.println("OK = " + ok);
 786         ok2 = checkAlternativeInfo(
 787             testGetSetByIndex_3.getClass(), "IGetSetByIndex-3");
 788         System.out.println("OK = " + ok2);
 789         passed = passed && (ok || ok2);
 790         */
 791 
 792         //----------------------------------------------------------------------
 793 
 794         // TODO: please uncomment/update after 8155013 fix
 795         /*
 796         IGetSetBoth testGetSetBoth_1 = new IGetSetBoth() {
 797 
 798             private double x[] = {X, X};
 799 
 800             @Override
 801             public double getX(int i) { return x[i]; }
 802             @BeanProperty(
 803                 description  = DESCRIPTION,
 804                 bound        = BOUND,
 805                 expert       = EXPERT,
 806                 hidden       = HIDDEN,
 807                 preferred    = PREFERRED,
 808                 required     = REQUIRED,
 809                 visualUpdate = UPDATE,
 810                 enumerationValues = {V_NAME})
 811             @Override
 812             public double[] getX() { return x; }
 813             @Override
 814             public void setX(int i, double v) { x[i] = v; }
 815             @Override
 816             public void setX(double[] a) { x = Arrays.copyOf(a, a.length); }
 817 
 818             public void addPropertyChangeListener(PropertyChangeListener l)    {}
 819             public void removePropertyChangeListener(PropertyChangeListener l) {}
 820         };
 821         ok = checkInfo(testGetSetBoth_1.getClass(), "IGetSetBoth-1", true);
 822         System.out.println("OK = " + ok);
 823         passed = passed && ok;
 824         */
 825 
 826         // TODO: please uncomment/update after 8155013 fix
 827         /*
 828         IGetSetBoth testGetSetBoth_2 = new IGetSetBoth() {
 829 
 830             private double x[] = {X, X};
 831 
 832             @Override
 833             public double getX(int i) { return x[i]; }
 834             @Override
 835             public double[] getX() { return x; }
 836             @Override
 837             public void setX(int i, double v) { x[i] = v; }
 838             @BeanProperty(
 839                 description  = DESCRIPTION,
 840                 bound        = BOUND,
 841                 expert       = EXPERT,
 842                 hidden       = HIDDEN,
 843                 preferred    = PREFERRED,
 844                 required     = REQUIRED,
 845                 visualUpdate = UPDATE,
 846                 enumerationValues = {V_NAME})
 847             @Override
 848             public void setX(double[] a) { x = Arrays.copyOf(a, a.length); }
 849 
 850             public void addPropertyChangeListener(PropertyChangeListener l)    {}
 851             public void removePropertyChangeListener(PropertyChangeListener l) {}
 852         };
 853         ok = checkInfo(testGetSetBoth_2.getClass(), "IGetSetBoth-2", true);
 854         System.out.println("OK = " + ok);
 855         passed = passed && ok;
 856         */
 857 
 858         // TODO: please uncomment/update after 8132973 fix
 859         /*
 860         IGetSetBoth testGetSetBoth_3 = new IGetSetBoth() {
 861 
 862             private double x[] = {X, X};
 863 
 864             @BeanProperty(
 865                 description  = DESCRIPTION,
 866                 bound        = BOUND,
 867                 expert       = EXPERT,
 868                 hidden       = HIDDEN,
 869                 preferred    = PREFERRED,
 870                 required     = REQUIRED,
 871                 visualUpdate = UPDATE,
 872                 enumerationValues = {V_NAME})
 873             @Override
 874             public double getX(int i) { return x[i]; }
 875             @Override
 876             public double[] getX() { return x; }
 877             @Override
 878             public void setX(int i, double v) { x[i] = v; }
 879             @BeanProperty(
 880                 description  = DESCRIPTION_2,
 881                 bound        = !BOUND,
 882                 expert       = !EXPERT,
 883                 hidden       = !HIDDEN,
 884                 preferred    = !PREFERRED,
 885                 required     = !REQUIRED,
 886                 visualUpdate = !UPDATE)
 887             @Override
 888             public void setX(double[] a) { x = Arrays.copyOf(a, a.length); }
 889 
 890             public void addPropertyChangeListener(PropertyChangeListener l)    {}
 891             public void removePropertyChangeListener(PropertyChangeListener l) {}
 892         };
 893         ok = checkInfo(testGetSetBoth_3.getClass(), "IGetSetBoth-3", true);
 894         System.out.println("OK = " + ok);
 895         ok2 = checkAlternativeInfo(
 896             testGetSetBoth_3.getClass(), "IGetSetBoth-3");
 897         System.out.println("OK = " + ok2);
 898         passed = passed && (ok || ok2);
 899         */
 900 
 901         //----------------------------------------------------------------------
 902 
 903         IIs testIs_1 = new IIs() {
 904 
 905             @BeanProperty(
 906                 description  = DESCRIPTION,
 907                 bound        = BOUND,
 908                 expert       = EXPERT,
 909                 hidden       = HIDDEN,
 910                 preferred    = PREFERRED,
 911                 required     = REQUIRED,
 912                 visualUpdate = UPDATE)
 913             @Override
 914             public boolean isX() { return false; }
 915 
 916             public void addPropertyChangeListener(PropertyChangeListener l)    {}
 917             public void removePropertyChangeListener(PropertyChangeListener l) {}
 918         };
 919         ok = checkInfo(testIs_1.getClass(), "IIs-1", false);
 920         System.out.println("OK = " + ok);
 921         passed = passed && ok;
 922 
 923 
 924         IIs testIs_2 = new IIs() {
 925 
 926             private boolean b;
 927 
 928             @Override
 929             public boolean isX() { return b; }
 930 
 931             @BeanProperty(
 932                 description  = DESCRIPTION,
 933                 bound        = BOUND,
 934                 expert       = EXPERT,
 935                 hidden       = HIDDEN,
 936                 preferred    = PREFERRED,
 937                 required     = REQUIRED,
 938                 visualUpdate = UPDATE)
 939             public void setX(boolean v) { b = v; }
 940 
 941             public void addPropertyChangeListener(PropertyChangeListener l)    {}
 942             public void removePropertyChangeListener(PropertyChangeListener l) {}
 943         };
 944         ok = checkInfo(testIs_2.getClass(), "IIs-2", false);
 945         System.out.println("OK = " + ok);
 946         passed = passed && ok;
 947 
 948 
 949         IIs testIs_3 = new IIs() {
 950 
 951             @BeanProperty(
 952                 description  = DESCRIPTION,
 953                 bound        = BOUND,
 954                 expert       = EXPERT,
 955                 hidden       = HIDDEN,
 956                 preferred    = PREFERRED,
 957                 required     = REQUIRED,
 958                 visualUpdate = UPDATE)
 959             @Override
 960             public boolean isX() { return false; }
 961 
 962             @BeanProperty(
 963                 description  = DESCRIPTION_2,
 964                 bound        = !BOUND,
 965                 expert       = !EXPERT,
 966                 hidden       = !HIDDEN,
 967                 preferred    = !PREFERRED,
 968                 required     = !REQUIRED,
 969                 visualUpdate = !UPDATE)
 970             public boolean getX() { return false; }
 971 
 972             public void addPropertyChangeListener(PropertyChangeListener l)    {}
 973             public void removePropertyChangeListener(PropertyChangeListener l) {}
 974         };
 975         ok = checkInfo(testIs_3.getClass(), "IIs-3", false);
 976         System.out.println("OK = " + ok);
 977         ok2 = checkAlternativeInfo(testIs_3.getClass(), "IIs-3");
 978         System.out.println("OK = " + ok2);
 979         passed = passed && (ok || ok2);
 980 
 981         // TODO: please uncomment/update after 8132973 fix
 982         /*
 983         IIs testIs_4 = new IIs() {
 984 
 985             private boolean b;
 986 
 987             @BeanProperty(
 988                 description  = DESCRIPTION,
 989                 bound        = BOUND,
 990                 expert       = EXPERT,
 991                 hidden       = HIDDEN,
 992                 preferred    = PREFERRED,
 993                 required     = REQUIRED,
 994                 visualUpdate = UPDATE)
 995             @Override
 996             public boolean isX() { return b; }
 997 
 998             @BeanProperty(
 999                 description  = DESCRIPTION_2,
1000                 bound        = !BOUND,
1001                 expert       = !EXPERT,
1002                 hidden       = !HIDDEN,
1003                 preferred    = !PREFERRED,
1004                 required     = !REQUIRED,
1005                 visualUpdate = !UPDATE)
1006             public void setX(boolean v) { b = v; }
1007 
1008             public void addPropertyChangeListener(PropertyChangeListener l)    {}
1009             public void removePropertyChangeListener(PropertyChangeListener l) {}
1010         };
1011         ok = checkInfo(testIs_4.getClass(), "IIs-4", false);
1012         System.out.println("OK = " + ok);
1013         ok2 = checkAlternativeInfo(testIs_4.getClass(), "IIs-4");
1014         System.out.println("OK = " + ok2);
1015         passed = passed && (ok || ok2);
1016         */
1017 
1018 
1019         //----------------------------------------------------------------------
1020 
1021 
1022         if (!passed) { throw new RuntimeException("test failed"); }
1023         System.out.println("\ntest passed");
1024     }
1025 }
< prev index next >