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 }