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 }
|