| /* |
| * 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"); |
| } |
| } |
