# HG changeset patch # User avstepan # Date 1438686229 -10800 # Node ID 5d1adcc1c3e619a54b40b9a2a0fdaa349dc98f9b # Parent f48fe5540347355a0a7a1fa9dba582c75e33422c 8131055: bean annotations: add a test checking if a user-defined BeanInfo is top-priority as compared with the annotations Reviewed-by: alexsch, serb diff -r f48fe5540347 -r 5d1adcc1c3e6 jdk/test/java/beans/Introspector/4058433/TestBeanInfoPriority.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/jdk/test/java/beans/Introspector/4058433/TestBeanInfoPriority.java Tue Aug 04 14:03:49 2015 +0300 @@ -0,0 +1,294 @@ +/* + * Copyright (c) 2015, 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.awt.event.ActionListener; +import java.awt.event.MouseListener; +import java.beans.BeanDescriptor; +import java.beans.BeanInfo; +import java.beans.BeanProperty; +import java.beans.EventSetDescriptor; +import java.beans.IntrospectionException; +import java.beans.Introspector; +import java.beans.JavaBean; +import java.beans.MethodDescriptor; +import java.beans.PropertyDescriptor; +import java.beans.SimpleBeanInfo; +import javax.swing.SwingContainer; +import java.util.Arrays; + +/** + * @test + * @bug 4058433 8131055 + * @summary Check if the user-defined bean info + * is not overridden with the annotated one. + * @author a.stepanov + */ + + +public class TestBeanInfoPriority { + + // ========== test bean (annotations must be ignored!) ========== + + @JavaBean( + description = "annotation-description", + defaultProperty = "other", + defaultEventSet = "mouse") + @SwingContainer(value = false) + public static class TestClass { + + private int value; + private double other; + + @BeanProperty( + bound = false, + expert = false, + hidden = false, + preferred = false, + required = false, + visualUpdate = false, + description = "annotation-value", + enumerationValues = { + "javax.swing.SwingConstants.NORTH"} + ) + public void setValue(int v) { value = v; } + public int getValue() { return value; } + + + @BeanProperty( + bound = true, + expert = true, + hidden = true, + preferred = true, + required = true, + visualUpdate = true, + description = "annotation-other", + enumerationValues = { + "javax.swing.SwingConstants.LEFT", + "javax.swing.SwingConstants.RIGHT", + "javax.swing.SwingConstants.CENTER"} + ) + public void setOther(double o) { other = o; } + public double getOther() { return other; } + + public void addActionListener(ActionListener l) {} + public void removeActionListener(ActionListener l) {} + + public void addMouseListener(MouseListener l) {} + public void removeMouseListener(MouseListener l) {} + } + + // ========== user-defined bean info ========== + + public static class TestClassBeanInfo extends SimpleBeanInfo { + + private static final int iOther = 0; + private static final int iValue = 1; + + private static final int iAction = 0; + private static final int iMouse = 1; + + + @Override + public BeanDescriptor getBeanDescriptor() { + + BeanDescriptor bd = new BeanDescriptor(TestClass.class, null); + bd.setShortDescription("user-defined-description"); + bd.setValue("isContainer", true); + bd.setValue("containerDelegate", "user-defined-delegate"); + + return bd; + } + + @Override + public PropertyDescriptor[] getPropertyDescriptors() { + + PropertyDescriptor[] p = new PropertyDescriptor[2]; + + try { + + // value + PropertyDescriptor pdValue = new PropertyDescriptor( + "value", TestClass.class, "getValue", "setValue"); + pdValue.setBound(true); + pdValue.setConstrained(true); + pdValue.setExpert(true); + pdValue.setHidden(true); + pdValue.setPreferred(true); + pdValue.setValue("required", true); + pdValue.setValue("visualUpdate", true); + pdValue.setShortDescription("user-defined-value"); + pdValue.setValue("enumerationValues", new Object[]{ + "EAST", 3, "javax.swing.SwingConstants.EAST", + "WEST", 7, "javax.swing.SwingConstants.WEST"}); + p[iValue] = pdValue; + + // other + PropertyDescriptor pdOther = new PropertyDescriptor( + "other", TestClass.class, "getOther", "setOther"); + pdOther.setBound(false); + pdOther.setConstrained(false); + pdOther.setExpert(false); + pdOther.setHidden(false); + pdOther.setPreferred(false); + pdOther.setValue("required", false); + pdOther.setValue("visualUpdate", false); + pdOther.setShortDescription("user-defined-other"); + pdOther.setValue("enumerationValues", new Object[]{ + "TOP", 1, "javax.swing.SwingConstants.TOP"}); + p[iOther] = pdOther; + + } catch(IntrospectionException e) { + e.printStackTrace(); + } + + return p; + } + + @Override + public EventSetDescriptor[] getEventSetDescriptors() { + EventSetDescriptor[] es = new EventSetDescriptor[2]; + try { + es[iAction] = new EventSetDescriptor( + TestClass.class, + "actionListener", + java.awt.event.ActionListener.class, + new String[] {"actionPerformed"}, + "addActionListener", + "removeActionListener"); + es[iMouse] = new EventSetDescriptor( + TestClass.class, + "mouseListener", + java.awt.event.MouseListener.class, + new String[] {"mouseClicked", "mousePressed", "mouseReleased", "mouseEntered", "mouseExited"}, + "addMouseListener", + "removeMouseListener"); + } catch(IntrospectionException e) { + e.printStackTrace(); + } + return es; + } + + @Override + public MethodDescriptor[] getMethodDescriptors() { + MethodDescriptor[] m = new MethodDescriptor[0]; + return m; + } + + @Override + public int getDefaultPropertyIndex() { return iValue; } // default: value + + @Override + public int getDefaultEventIndex() { return iAction; } // default: action + + @Override + public java.awt.Image getIcon(int iconKind) { return null; } + } + + // ========== auxiliary functions ========== + + static void checkEq(String what, Object v, Object ref) throws Exception { + + if ((v != null) && v.equals(ref)) { + System.out.println(what + ": ok (" + ref.toString() + ")"); + } else { + throw new Exception( + "invalid " + what + ", expected: \"" + ref + "\", got: \"" + v + "\""); + } + } + + static void checkEnumEq(String what, Object v, Object ref[]) throws Exception { + + what = "\"" + what + "\""; + if (v == null) { + throw new Exception("null " + what + " enumeration values"); + } + + String msg = "invalid " + what + " enumeration values"; + if (!(v instanceof Object[])) { throw new Exception(msg); } + + if (Arrays.equals((Object []) v, ref)) { + System.out.println(what + " enumeration values: ok"); + } else { throw new Exception(msg); } + } + + + // ========== test ========== + + + public static void main(String[] args) throws Exception { + + BeanInfo i = Introspector.getBeanInfo(TestClass.class, Object.class); + BeanDescriptor bd = i.getBeanDescriptor(); + + checkEq("description", bd.getShortDescription(), "user-defined-description"); + checkEq("default property index", i.getDefaultPropertyIndex(), 1); + checkEq("default event index", i.getDefaultEventIndex(), 0); + + checkEq("isContainer", i.getBeanDescriptor().getValue("isContainer"), true); + checkEq("containerDelegate", + i.getBeanDescriptor().getValue("containerDelegate"), "user-defined-delegate"); + System.out.println(""); + + PropertyDescriptor[] pds = i.getPropertyDescriptors(); + for (PropertyDescriptor pd: pds) { + String name = pd.getName(); + switch (name) { + case "value": + checkEq("\"value\" isBound", pd.isBound(), true); + checkEq("\"value\" isConstrained", pd.isConstrained(), true); + checkEq("\"value\" isExpert", pd.isExpert(), true); + checkEq("\"value\" isHidden", pd.isHidden(), true); + checkEq("\"value\" isPreferred", pd.isPreferred(), true); + checkEq("\"value\" required", pd.getValue("required"), true); + checkEq("\"value\" visualUpdate", pd.getValue("visualUpdate"), true); + + checkEq("\"value\" description", pd.getShortDescription(), "user-defined-value"); + + checkEnumEq(pd.getName(), pd.getValue("enumerationValues"), + new Object[]{ + "EAST", 3, "javax.swing.SwingConstants.EAST", + "WEST", 7, "javax.swing.SwingConstants.WEST"}); + System.out.println(""); + break; + case "other": + checkEq("\"other\" isBound", pd.isBound(), false); + checkEq("\"other\" isConstrained", pd.isConstrained(), false); + checkEq("\"other\" isExpert", pd.isExpert(), false); + checkEq("\"other\" isHidden", pd.isHidden(), false); + checkEq("\"other\" isPreferred", pd.isPreferred(), false); + checkEq("\"other\" required", pd.getValue("required"), false); + checkEq("\"other\" visualUpdate", pd.getValue("visualUpdate"), false); + + checkEq("\"other\" description", pd.getShortDescription(), "user-defined-other"); + + checkEnumEq(pd.getName(), pd.getValue("enumerationValues"), + new Object[]{"TOP", 1, "javax.swing.SwingConstants.TOP"}); + System.out.println(""); + break; + default: + throw new Exception("invalid property descriptor: " + name); + } + } + } +}