--- /dev/null 2016-03-31 18:33:52.540182992 +0300 +++ new/test/java/beans/Introspector/InheritanceBeanPropertyTest.java 2016-04-28 17:00:58.598199692 +0300 @@ -0,0 +1,1281 @@ +/* + * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +import java.beans.BeanInfo; +import java.beans.BeanProperty; +import java.beans.IntrospectionException; +import java.beans.Introspector; +import java.beans.PropertyChangeListener; +import java.beans.PropertyDescriptor; + +import java.util.Arrays; + + +/** + * @test + * @bug 8132565 8155013 + * @summary Some inheritance check for BeanProperty annotation + * @author a.stepanov + * @run main InheritanceBeanPropertyTest + */ + + +public class InheritanceBeanPropertyTest { + + private final static String DESCRIPTION = "TEST"; + private final static boolean BOUND = true; + private final static boolean EXPERT = false; + private final static boolean HIDDEN = true; + private final static boolean PREFERRED = false; + private final static boolean REQUIRED = true; + private final static boolean UPDATE = false; + + private final static double X = java.lang.Math.PI; + + private final static String + V_NAME = "java.lang.Math.PI", + V_SHORT = "PI", + V = Double.toString(X); + + private final static String DESCRIPTION_2 = "XYZ"; + + + // ---------- test cases ---------- + + public static class BaseGet { + + private final static String TESTCASE = "base getter"; + + public double getX() { return X; } + } + + public static class OverloadGet extends BaseGet { + + private final static String TESTCASE = "overload getter"; + + private final double x[] = {X, X, X}; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE, + enumerationValues = {V_NAME}) + public double getX(int i) { return x[i]; } // indexed + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + // ---------- + + public static class BaseSet { + + private final static String TESTCASE = "base setter"; + + double u; + public void setX(double v) { u = v; } + } + + public static class OverloadSet extends BaseSet { + + private final static String TESTCASE = "overload setter"; + + private final double x[] = {X, X, X}; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE, + enumerationValues = {V_NAME}) + public void setX(int i, double v) { x[i] = v; } // indexed + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + // ---------- + + public static class BaseIGet { + + protected final double x[] = {X, X, X}; + public double[] getX() { return x; } + } + + public static class OverloadIGet extends BaseIGet { + + private final static String TESTCASE = "overload indexed getter"; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE, + enumerationValues = {V_NAME}) + public double getX(int i) { return x[i]; } + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + // ---------- + + public static class BaseISet { + + protected double x[] = {X, X, X}; + public void setX(double a[]) { x = Arrays.copyOf(a, a.length); } + } + + public static class OverloadISet extends BaseISet { + + private final static String TESTCASE = "overload indexed setter"; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE, + enumerationValues = {V_NAME}) + public void setX(int i, double v) { x[i] = v; } + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + // ---------- + + public static class BoolGet { + + @BeanProperty( + description = DESCRIPTION_2, + bound = !BOUND, + expert = !EXPERT, + hidden = !HIDDEN, + preferred = !PREFERRED, + required = !REQUIRED, + visualUpdate = !UPDATE) + public boolean getX() { return false; } + } + + public static class BoolGetIs extends BoolGet { + + private final static String TESTCASE = "base boolean getter + is"; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE) + public boolean isX() { return false; } + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + // ---------- + + public static class BoolIs { + + @BeanProperty( + description = DESCRIPTION_2, + bound = !BOUND, + expert = !EXPERT, + hidden = !HIDDEN, + preferred = !PREFERRED, + required = !REQUIRED, + visualUpdate = !UPDATE) + public boolean isX() { return false; } + } + + public static class BoolIsGet extends BoolIs { + + private final static String TESTCASE = "base is + boolean getter"; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE) + public boolean getX() { return false; } + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + // ---------- + + public static class AnnotatedGet { + + private final static String TESTCASE = "annotated super getter"; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE, + enumerationValues = {V_NAME}) + public double getX() { return 0.; } + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + public static class OverrideAnnotatedGet extends AnnotatedGet { + + private final static String TESTCASE = "override annotated getter"; + + @Override + public double getX() { return X; } + } + + // ---------- + + public static class AnnotatedIs { + + private final static String TESTCASE = "annotated super is"; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE, + enumerationValues = {V_NAME}) + public boolean isX() { return false; } + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + public static class OverrideAnnotatedIs extends AnnotatedIs { + + private final static String TESTCASE = "override annotated is"; + + @Override + public boolean isX() { return false; } + } + + // ---------- + + public static class AnnotatedSet { + + private final static String TESTCASE = "annotated super set"; + + protected double x; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE, + enumerationValues = {V_NAME}) + public void setX(double v) { x = -v; } + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + public static class OverrideAnnotatedSet extends AnnotatedSet { + + private final static String TESTCASE = "override annotated setter"; + + @Override + public void setX(double v) { x = v; } + } + + // ---------- + + public static class AnnotatedGet2 { + + protected double x; + + @BeanProperty( + description = DESCRIPTION_2, + bound = !BOUND, + expert = !EXPERT, + hidden = !HIDDEN, + preferred = !PREFERRED, + required = !REQUIRED, + visualUpdate = !UPDATE) + public double getX() { return 0.; } + } + + public static class OverrideAnnotatedGet2 extends AnnotatedGet2 { + + private final static String TESTCASE = "override annotated getter - 2"; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE, + enumerationValues = {V_NAME}) + @Override + public double getX() { return X; } + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + public static class AnnotatedGet2Ext extends AnnotatedGet2 { + + private final static String TESTCASE = "extend annotated getter - 2"; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE, + enumerationValues = {V_NAME}) + public void setX(double v) { x = v; } + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + // ---------- + + public static class AnnotatedIs2 { + + protected boolean b = false; + + @BeanProperty( + description = DESCRIPTION_2, + bound = !BOUND, + expert = !EXPERT, + hidden = !HIDDEN, + preferred = !PREFERRED, + required = !REQUIRED, + visualUpdate = !UPDATE) + public boolean isX() { return false; } + } + + public static class OverrideAnnotatedIs2 extends AnnotatedIs2 { + + private final static String TESTCASE = "override annotated is - 2"; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE) + @Override + public boolean isX() { return b; } + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + public static class AnnotatedIs2Ext extends AnnotatedIs2 { + + private final static String TESTCASE = "extend annotated is - 2"; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE) + public void setX(boolean v) { b = v; } + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + // ---------- + + public static class AnnotatedSet2 { + + protected double x; + + @BeanProperty( + description = DESCRIPTION_2, + bound = !BOUND, + expert = !EXPERT, + hidden = !HIDDEN, + preferred = !PREFERRED, + required = !REQUIRED, + visualUpdate = !UPDATE) + public void setX(double v) { x = -v; } + } + + public static class OverrideAnnotatedSet2 extends AnnotatedSet2 { + + private final static String TESTCASE = "override annotated setter - 2"; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE, + enumerationValues = {V_NAME}) + @Override + public void setX(double v) { x = v; } + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + public static class AnnotatedSet2Ext extends AnnotatedSet2 { + + private final static String TESTCASE = "extend annotated setter - 2"; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE, + enumerationValues = {V_NAME}) + public double getX() { return x; } + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + // ---------- + + public abstract static class AbstractGet { + + @BeanProperty( + description = DESCRIPTION_2, + bound = !BOUND, + expert = !EXPERT, + hidden = !HIDDEN, + preferred = !PREFERRED, + required = !REQUIRED, + visualUpdate = !UPDATE) + public abstract double getX(); + } + + public static class OverrideAbstractGet extends AbstractGet { + + private final static String TESTCASE = + "override abstract annotated getter"; + + @Override + public double getX() { return X; } + } + + public static class OverrideAbstractGet2 extends AbstractGet { + + private final static String TESTCASE = + "override abstract annotated getter - 2"; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE, + enumerationValues = {V_NAME}) + @Override + public double getX() { return X; } + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + public abstract static class AbstractGetExt extends AbstractGet { + + private final static String TESTCASE = + "extend abstract annotated getter"; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE, + enumerationValues = {V_NAME}) + public abstract void setX(double v); + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + // ---------- + + public abstract static class AbstractIs { + + @BeanProperty( + description = DESCRIPTION_2, + bound = !BOUND, + expert = !EXPERT, + hidden = !HIDDEN, + preferred = !PREFERRED, + required = !REQUIRED, + visualUpdate = !UPDATE) + public abstract boolean isX(); + } + + public static class OverrideAbstractIs extends AbstractIs { + + private final static String TESTCASE = + "override abstract annotated is"; + + @Override + public boolean isX() { return true; } + } + + public static class OverrideAbstractIs2 extends AbstractIs { + + private final static String TESTCASE = + "override abstract annotated is - 2"; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE) + @Override + public boolean isX() { return true; } + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + + public abstract static class AbstractIsExt extends AbstractIs { + + private final static String TESTCASE = + "extend abstract annotated is"; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE) + public abstract boolean getX(); + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + // ---------- + + public abstract static class AbstractSet { + + @BeanProperty( + description = DESCRIPTION_2, + bound = !BOUND, + expert = !EXPERT, + hidden = !HIDDEN, + preferred = !PREFERRED, + required = !REQUIRED, + visualUpdate = !UPDATE) + public abstract void setX(double v); + } + + public static class OverrideAbstractSet extends AbstractSet { + + private final static String TESTCASE = + "override abstract annotated setter"; + + private double x; + + @Override + public void setX(double v) { x = v; } + } + + public static class OverrideAbstractSet2 extends AbstractSet { + + private final static String TESTCASE = + "override abstract annotated setter - 2"; + + private double x; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE, + enumerationValues = {V_NAME}) + @Override + public void setX(double v) { x = v; } + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + public abstract static class AbstractSetExt extends AbstractSet { + + private final static String TESTCASE = + "extend abstract annotated setter"; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE, + enumerationValues = {V_NAME}) + public abstract void setX(double v[]); + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + // ---------- + + public static abstract class AbstractGet2 { + + private final static String TESTCASE = "abstract super getter"; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE, + enumerationValues = {V_NAME}) + public abstract double getX(); + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + public static abstract class AbstractGet2Ext extends AbstractGet2 { + + @BeanProperty( + description = DESCRIPTION_2, + bound = !BOUND, + expert = !EXPERT, + hidden = !HIDDEN, + preferred = !PREFERRED, + required = !REQUIRED, + visualUpdate = !UPDATE) + public abstract void setX(double a[]); + } + + // ---------- + + public static interface IGet { + + @BeanProperty( + description = DESCRIPTION_2, + bound = !BOUND, + expert = !EXPERT, + hidden = !HIDDEN, + preferred = !PREFERRED, + required = !REQUIRED, + visualUpdate = !UPDATE) + double getX(); + } + + public static class IGetImpl implements IGet { + + private final static String TESTCASE = "implement getter interface"; + + @Override + public double getX() { return X; } + } + + public static class IGetImpl2 implements IGet { + + private final static String TESTCASE = "implement getter interface - 2"; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE, + enumerationValues = {V_NAME}) + @Override + public double getX() { return X; } + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + public abstract static class IGetImpl3 implements IGet { + + private final static String TESTCASE = "implement getter interface - 3"; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE, + enumerationValues = {V_NAME}) + public abstract void setX(double v); + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + // ---------- + + public static interface IIs { + + @BeanProperty( + description = DESCRIPTION_2, + bound = !BOUND, + expert = !EXPERT, + hidden = !HIDDEN, + preferred = !PREFERRED, + required = !REQUIRED, + visualUpdate = !UPDATE) + public boolean isX(); + } + + public static class IIsImpl implements IIs { + + private final static String TESTCASE = "implement is interface"; + + @Override + public boolean isX() { return true; } + } + + public static class IIsImpl2 implements IIs { + + private final static String TESTCASE = "implement is interface - 2"; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE) + @Override + public boolean isX() { return true; } + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + public abstract static class IIsImpl3 implements IIs { + + private final static String TESTCASE = "implement is interface - 3"; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE) + public abstract void setX(boolean v); + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + // ---------- + + public static interface ISet { + + @BeanProperty( + description = DESCRIPTION_2, + bound = !BOUND, + expert = !EXPERT, + hidden = !HIDDEN, + preferred = !PREFERRED, + required = !REQUIRED, + visualUpdate = !UPDATE) + public void setX(double v); + } + + public static class ISetImpl implements ISet { + + private final static String TESTCASE = "implement getter interface"; + + private double x; + + @Override + public void setX(double v) { x = v; } + } + + public static class ISetImpl2 implements ISet { + + private final static String TESTCASE = "implement getter interface - 2"; + + private double x; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE, + enumerationValues = {V_NAME}) + @Override + public void setX(double v) { x = v; } + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + public abstract static class ISetImpl3 implements ISet { + + private final static String TESTCASE = "implement getter interface - 3"; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE, + enumerationValues = {V_NAME}) + public abstract double getX(); + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + // ---------- + + public static interface ISet2 { + + final static String TESTCASE = "super interface - setter"; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE, + enumerationValues = {V_NAME}) + public void setX(double v); + + public void addPropertyChangeListener(PropertyChangeListener l); + public void removePropertyChangeListener(PropertyChangeListener l); + } + + public static class ISet2Impl implements ISet2 { + + private double x; + + @BeanProperty( + description = DESCRIPTION_2, + bound = !BOUND, + expert = !EXPERT, + hidden = !HIDDEN, + preferred = !PREFERRED, + required = !REQUIRED, + visualUpdate = !UPDATE) + @Override + public void setX(double v) { x = v; } + + @Override + public void addPropertyChangeListener(PropertyChangeListener l) {} + @Override + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + // ---------- + + public static interface IGet2 { + + final static String TESTCASE = "super interface - indexed getter"; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE, + enumerationValues = {V_NAME}) + public double[] getX(); + + public void addPropertyChangeListener(PropertyChangeListener l); + public void removePropertyChangeListener(PropertyChangeListener l); + } + + public static class IGet2Impl implements IGet2 { + + @BeanProperty( + description = DESCRIPTION_2, + bound = !BOUND, + expert = !EXPERT, + hidden = !HIDDEN, + preferred = !PREFERRED, + required = !REQUIRED, + visualUpdate = !UPDATE) + @Override + public double[] getX() { return new double[]{X, X}; } + + @Override + public void addPropertyChangeListener(PropertyChangeListener l) {} + @Override + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + // ---------- + + public static class ProtectedGet { + + @BeanProperty( + description = DESCRIPTION_2, + bound = !BOUND, + expert = !EXPERT, + hidden = !HIDDEN, + preferred = !PREFERRED, + required = !REQUIRED, + visualUpdate = !UPDATE) + protected double getX() { return 0.; } + } + + public static class OverrideProtectedGet extends ProtectedGet { + + final static String TESTCASE = "override protected getter"; + + @BeanProperty( + description = DESCRIPTION, + bound = BOUND, + expert = EXPERT, + hidden = HIDDEN, + preferred = PREFERRED, + required = REQUIRED, + visualUpdate = UPDATE, + enumerationValues = {V_NAME}) + @Override + public double getX() { return X; } + + public void addPropertyChangeListener(PropertyChangeListener l) {} + public void removePropertyChangeListener(PropertyChangeListener l) {} + } + + // ---------- + + // static getter - see also JDK-8154938 + public static class StaticGet { + + @BeanProperty( + description = DESCRIPTION_2, + bound = !BOUND, + expert = !EXPERT, + hidden = !HIDDEN, + preferred = !PREFERRED, + required = !REQUIRED, + visualUpdate = !UPDATE) + public static double getProp() { return 0.; } + } + + public static class HideStaticGet extends StaticGet { + + final static String TESTCASE = "hide static getter"; + + public double getX() { return X; } // add to get the "default" info + public static double getProp() { return X; } + } + + // TODO: if 8154938 is considered to be a real issue, + // create one more test case "HideStaticGet2 extends StaticGet" with an + // annotated getter and check the correctness of the corresponding bean info + + // ---------- checks ---------- + + private static boolean check(String what, boolean v, boolean ref) { + + boolean ok = (v == ref); + if (!ok) { System.out.println( + "invalid " + what + ": " + v + ", expected: " + ref); } + return ok; + } + + private static boolean checkInfo(BeanInfo i, boolean ignoreValsCheck) { + + System.out.println("checking info..."); + + PropertyDescriptor descriptors[] = i.getPropertyDescriptors(); + int nd = descriptors.length; + if (nd != 1) { + System.out.println("invalid number of descriptors: " + nd); + return false; + } + + PropertyDescriptor d = descriptors[0]; + + String descr = d.getShortDescription(); + boolean ok = descr.equals(DESCRIPTION); + if (!ok) { System.out.println("invalid description: " + descr + + ", expected: " + DESCRIPTION); } + + ok &= check("isBound", d.isBound(), BOUND); + ok &= check("isExpert", d.isExpert(), EXPERT); + ok &= check("isHidden", d.isHidden(), HIDDEN); + ok &= check("isPreferred", d.isPreferred(), PREFERRED); + ok &= check("required", (boolean) d.getValue("required"), REQUIRED); + ok &= check("visualUpdate", + (boolean) d.getValue("visualUpdate"), UPDATE); + + if (ignoreValsCheck) { return ok; } + + Object vals[] = (Object[]) d.getValue("enumerationValues"); + if (vals == null) { + System.out.println("null enumerationValues"); + return false; + } + + boolean okVals = ( + (vals.length == 3) && + vals[0].toString().equals(V_SHORT) && + vals[1].toString().equals(V) && + vals[2].toString().equals(V_NAME)); + + if (!okVals) { System.out.println("invalid enumerationValues"); } + + return (ok && okVals); + } + + private static boolean checkDefault(BeanInfo i) { + + System.out.println("checking default info..."); + + PropertyDescriptor descriptors[] = i.getPropertyDescriptors(); + int nd = descriptors.length; + if (nd != 1) { + System.out.println("invalid number of descriptors: " + nd); + return false; + } + + PropertyDescriptor d = descriptors[0]; + + String descr = d.getShortDescription(); + boolean ok = descr.equals("x"); + if (!ok) { System.out.println("invalid description: " + descr + + ", expected: x"); } + + ok &= check("isBound", d.isBound(), false); + ok &= check("isExpert", d.isExpert(), false); + ok &= check("isHidden", d.isHidden(), false); + ok &= check("isPreferred", d.isPreferred(), false); + ok &= check("required", (boolean) d.getValue("required"), false); + ok &= check("visualUpdate", + (boolean) d.getValue("visualUpdate"), false); + + Object vals[] = (Object[]) d.getValue("enumerationValues"); + if (vals != null && vals.length > 0) { + System.out.println("non-empty enumerationValues"); + ok = false; + } + + return ok; + } + + // do not check enumerationValues for these classes + private static boolean ignoreVals(Class c) { + return ( + c.equals(BoolGetIs.class) || + c.equals(BoolIsGet.class) || + c.equals(AnnotatedIs.class) || + c.equals(OverrideAnnotatedIs2.class) || + c.equals(AnnotatedIs2Ext.class) || + c.equals(OverrideAbstractIs.class) || + c.equals(OverrideAbstractIs2.class) || + c.equals(AbstractIsExt.class) || + c.equals(OverrideAbstractIs.class) || + c.equals(IIsImpl.class) || + c.equals(IIsImpl2.class) || + c.equals(IIsImpl3.class) + ); + } + + // default property descriptor data are expected for these classes + private static boolean isDefault(Class c) { + return ( + c.equals(OverrideAnnotatedGet.class) || + c.equals(OverrideAnnotatedIs.class ) || + c.equals(OverrideAnnotatedSet.class) || + c.equals(OverrideAbstractGet.class) || + c.equals(OverrideAbstractIs.class) || + c.equals(OverrideAbstractSet.class) || + c.equals(IGetImpl.class) || + c.equals(IIsImpl.class) || + c.equals(ISetImpl.class) || + c.equals(BaseGet.class) || + c.equals(BaseSet.class) || + c.equals(HideStaticGet.class) + ); + } + + + // ---------- run test ---------- + + public static void main(String[] args) throws Exception { + + Class + ic1 = ISet2Impl.class.getInterfaces()[0], + ic2 = IGet2Impl.class.getInterfaces()[0]; + + Class cases[] = { + + OverloadGet.class, + OverloadGet.class.getSuperclass(), + OverloadSet.class, + OverloadSet.class.getSuperclass(), + OverloadIGet.class, + OverloadISet.class, + + // TODO: uncomment/update after 8132565 fix + //BoolGetIs.class, + //BoolIsGet.class, + //OverrideAnnotatedGet.class, + //OverrideAnnotatedIs.class, + //OverrideAnnotatedSet.class, + //OverrideAnnotatedGet2.class, + //AnnotatedGet2Ext.class, + //OverrideAnnotatedIs2.class + //AnnotatedIs2Ext.class, + //OverrideAnnotatedSet2.class, + //AnnotatedSet2Ext.class, + + OverrideAnnotatedGet.class.getSuperclass(), + OverrideAnnotatedIs.class.getSuperclass(), + OverrideAnnotatedSet.class.getSuperclass(), + + // TODO: uncomment/update after 8132565 fix + //OverrideAbstractGet.class, + //OverrideAbstractGet2.class, + //AbstractGetExt.class, + //OverrideAbstractIs.class, + //OverrideAbstractIs2.class, + //AbstractIsExt.class + //OverrideAbstractSet.class, + //OverrideAbstractSet2.class, + //AbstractSetExt.class, + + AbstractGet2Ext.class.getSuperclass(), + IGetImpl.class, + IGetImpl2.class, + IGetImpl3.class, + IIsImpl.class, + IIsImpl2.class, + IIsImpl3.class, + ISetImpl.class, + ISetImpl2.class, + ISetImpl3.class, + ic1, + // ic2, // TODO: uncomment/update after 8155013 fix + OverrideProtectedGet.class, + HideStaticGet.class + }; + + boolean passed = true; + + for (Class c: cases) { + + java.lang.reflect.Field f = c.getDeclaredField("TESTCASE"); + f.setAccessible(true); + String descr = f.get(c).toString(); + + System.out.println("\n" + c.getSimpleName() + " (" + descr + "):"); + BeanInfo i; + try { + i = Introspector.getBeanInfo(c, + (c.equals(ic1) || c.equals(ic2)) ? null : Object.class); + } + catch (IntrospectionException e) { throw new RuntimeException(e); } + + boolean ok; + + if (isDefault(c)) { + ok = checkDefault(i); + } else { + ok = checkInfo(i, ignoreVals(c)); + } + System.out.println(ok ? "OK" : "NOK"); + passed = passed && ok; + } + + if (!passed) { throw new RuntimeException("test failed"); } + System.out.println("\ntest passed"); + } +}