jdk/test/javax/management/Introspector/AnnotationTest.java

/*
 * Copyright 2005 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
 * CA 95054 USA or visit www.sun.com if you need additional information or
 * have any questions.
 */

/*
 * @test
 * @bug 6221321 6295867
 * @summary Test that annotations in Standard MBean interfaces
 * correctly produce Descriptor entries
 * @author Eamonn McManus
 * @run clean AnnotationTest
 * @run build AnnotationTest
 * @run main AnnotationTest
 */

import java.lang.annotation.*;
import java.lang.reflect.*;
import java.util.*;
import javax.management.*;

/*
  This test checks that annotations produce Descriptor entries as
  specified in javax.management.DescriptorKey.  It does two things:

  - An annotation consisting of an int and a String, each with an
    appropriate @DescriptorKey annotation, is placed on every program
    element where it can map to a Descriptor, namely:

    . on an MBean interface
    . on a getter for a read-only attribute
    . on a setter for a write-only attribute
    . on the getter but not the setter for a read/write attribute
    . on the setter but not the getter for a read/write attribute
    . on both the getter and the setter for a read/write attribute
    . on an operation
    . on each parameter of an operation
    . on a public constructor with no parameters
    . on a public constructor with a parameter
    . on the parameter of that public constructor
    . on all of the above for an MXBean instead of an MBean

    The test checks that in each case the corresponding Descriptor
    appears in the appropriate place inside the MBean's MBeanInfo.

  - An annotation consisting of enough other types to ensure coverage
    is placed on a getter.  The test checks that the generated
    MBeanAttributeInfo contains the corresponding Descriptor.  The tested
    types are the following:

    . Class
    . an enumeration type (java.lang.annotation.RetentionPolicy)
    . boolean
    . String[]
    . Class[]
    . int[]
    . an array of enumeration type (RetentionPolicy[])
    . boolean[]
 */
public class AnnotationTest {
    private static String failed = null;

//    @Retention(RetentionPolicy.RUNTIME) @Inherited
//    @Target(ElementType.METHOD)
//    public static @interface DescriptorKey {
//        String value();
//    }

    @Retention(RetentionPolicy.RUNTIME)
    public static @interface Pair {
        @DescriptorKey("x")
        int x();
        @DescriptorKey("y")
        String y();
    }

    @Retention(RetentionPolicy.RUNTIME)
    public static @interface Full {
        @DescriptorKey("class")
        Class classValue();
        @DescriptorKey("enum")
        RetentionPolicy enumValue();
        @DescriptorKey("boolean")
        boolean booleanValue();
        @DescriptorKey("stringArray")
        String[] stringArrayValue();
        @DescriptorKey("classArray")
        Class[] classArrayValue();
        @DescriptorKey("intArray")
        int[] intArrayValue();
        @DescriptorKey("enumArray")
        RetentionPolicy[] enumArrayValue();
        @DescriptorKey("booleanArray")
        boolean[] booleanArrayValue();
    }

    /* We use the annotation @Pair(x = 3, y = "foo") everywhere, and this is
       the Descriptor that it should produce: */
    private static Descriptor expectedDescriptor =
        new ImmutableDescriptor(new String[] {"x", "y"},
                                new Object[] {3, "foo"});

    private static Descriptor expectedFullDescriptor =
        new ImmutableDescriptor(new String[] {
                                    "class", "enum", "boolean", "stringArray",
                                    "classArray", "intArray", "enumArray",
                                    "booleanArray",
                                },
                                new Object[] {
                                    Full.class.getName(),
                                    RetentionPolicy.RUNTIME.name(),
                                    false,
                                    new String[] {"foo", "bar"},
                                    new String[] {Full.class.getName()},
                                    new int[] {1, 2},
                                    new String[] {RetentionPolicy.RUNTIME.name()},
                                    new boolean[] {false, true},
                                });

    @Pair(x = 3, y = "foo")
    public static interface ThingMBean {
        @Pair(x = 3, y = "foo")
        @Full(classValue=Full.class,
              enumValue=RetentionPolicy.RUNTIME,
              booleanValue=false,
              stringArrayValue={"foo", "bar"},
              classArrayValue={Full.class},
              intArrayValue={1, 2},
              enumArrayValue={RetentionPolicy.RUNTIME},
              booleanArrayValue={false, true})
        int getReadOnly();

        @Pair(x = 3, y = "foo")
        void setWriteOnly(int x);

        @Pair(x = 3, y = "foo")
        int getReadWrite1();
        void setReadWrite1(int x);

        @Pair(x = 3, y = "foo")
        int getReadWrite2();
        @Pair(x = 3, y = "foo")
        void setReadWrite2(int x);

        int getReadWrite3();
        @Pair(x = 3, y = "foo")
        void setReadWrite3(int x);

        @Pair(x = 3, y = "foo")
        int operation(@Pair(x = 3, y = "foo") int p1,
                      @Pair(x = 3, y = "foo") int p2);
    }

    public static class Thing implements ThingMBean {
        @Pair(x = 3, y = "foo")
        public Thing() {}

        @Pair(x = 3, y = "foo")
        public Thing(@Pair(x = 3, y = "foo") int p1) {}

        public int getReadOnly() {return 0;}

        public void setWriteOnly(int x) {}

        public int getReadWrite1() {return 0;}
        public void setReadWrite1(int x) {}

        public int getReadWrite2() {return 0;}
        public void setReadWrite2(int x) {}

        public int getReadWrite3() {return 0;}
        public void setReadWrite3(int x) {}

        public int operation(int p1, int p2) {return 0;}
    }

    @Pair(x = 3, y = "foo")
    public static interface ThingMXBean extends ThingMBean {}

    public static class ThingImpl implements ThingMXBean {
        @Pair(x = 3, y = "foo")
        public ThingImpl() {}

        @Pair(x = 3, y = "foo")
        public ThingImpl(@Pair(x = 3, y = "foo") int p1) {}

        public int getReadOnly() {return 0;}

        public void setWriteOnly(int x) {}

        public int getReadWrite1() {return 0;}
        public void setReadWrite1(int x) {}

        public int getReadWrite2() {return 0;}
        public void setReadWrite2(int x) {}

        public int getReadWrite3() {return 0;}
        public void setReadWrite3(int x) {}

        public int operation(int p1, int p2) {return 0;}
    }

    public static void main(String[] args) throws Exception {
        System.out.println("Testing that annotations are correctly " +
                           "reflected in Descriptor entries");

        MBeanServer mbs =
            java.lang.management.ManagementFactory.getPlatformMBeanServer();
        ObjectName on = new ObjectName("a:b=c");
        Thing thing = new Thing();
        mbs.registerMBean(thing, on);
        check(mbs, on);
        mbs.unregisterMBean(on);
        ThingImpl thingImpl = new ThingImpl();
        mbs.registerMBean(thingImpl, on);
        check(mbs, on);

        if (failed == null)
            System.out.println("Test passed");
        else if (true)
            throw new Exception("TEST FAILED: " + failed);
        else
            System.out.println("Test disabled until 6221321 implemented");
    }

    private static void check(MBeanServer mbs, ObjectName on) throws Exception {
        MBeanInfo mbi = mbs.getMBeanInfo(on);

        // check the MBean itself
        check(mbi);

        // check attributes
        MBeanAttributeInfo[] attrs = mbi.getAttributes();
        for (MBeanAttributeInfo attr : attrs) {
            check(attr);
            if (attr.getName().equals("ReadOnly"))
                check("@Full", attr.getDescriptor(), expectedFullDescriptor);
        }

        // check operations
        MBeanOperationInfo[] ops = mbi.getOperations();
        for (MBeanOperationInfo op : ops) {
            check(op);
            check(op.getSignature());
        }

        MBeanConstructorInfo[] constrs = mbi.getConstructors();
        for (MBeanConstructorInfo constr : constrs) {
            check(constr);
            check(constr.getSignature());
        }
    }

    private static void check(DescriptorRead x) {
        check(x, x.getDescriptor(), expectedDescriptor);
    }

    private static void check(Object x, Descriptor d, Descriptor expect) {
        String fail = null;
        try {
            Descriptor u = ImmutableDescriptor.union(d, expect);
            if (!u.equals(d))
                fail = "should contain " + expect + "; is " + d;
        } catch (IllegalArgumentException e) {
            fail = e.getMessage();
        }
        if (fail == null) {
            System.out.println("OK: " + x);
        } else {
            failed = "NOT OK: Incorrect descriptor for: " + x;
            System.out.println(failed);
            System.out.println("..." + fail);
        }
    }

    private static void check(DescriptorRead[] xx) {
        for (DescriptorRead x : xx)
            check(x);
    }

    public static class AnnotatedMBean extends StandardMBean {
        <T> AnnotatedMBean(T resource, Class<T> interfaceClass, boolean mx) {
            super(resource, interfaceClass, mx);
        }

        private static final String[] attrPrefixes = {"get", "set", "is"};

        protected void cacheMBeanInfo(MBeanInfo info) {
            MBeanAttributeInfo[] attrs = info.getAttributes();
            MBeanOperationInfo[] ops = info.getOperations();

            for (int i = 0; i < attrs.length; i++) {
                MBeanAttributeInfo attr = attrs[i];
                String name = attr.getName();
                Descriptor d = attr.getDescriptor();
                Method m;
                if ((m = getMethod("get" + name)) != null)
                    d = ImmutableDescriptor.union(d, descriptorFor(m));
                if (attr.getType().equals("boolean") &&
                        (m = getMethod("is" + name)) != null)
                    d = ImmutableDescriptor.union(d, descriptorFor(m));
                if ((m = getMethod("set" + name, attr)) != null)
                    d = ImmutableDescriptor.union(d, descriptorFor(m));
                if (!d.equals(attr.getDescriptor())) {
                    attrs[i] =
                        new MBeanAttributeInfo(name, attr.getType(),
                            attr.getDescription(), attr.isReadable(),
                            attr.isWritable(), attr.isIs(), d);
                }
            }

            for (int i = 0; i < ops.length; i++) {
                MBeanOperationInfo op = ops[i];
                String name = op.getName();
                Descriptor d = op.getDescriptor();
                MBeanParameterInfo[] params = op.getSignature();
                Method m = getMethod(name, params);
                if (m != null) {
                    d = ImmutableDescriptor.union(d, descriptorFor(m));
                    Annotation[][] annots = m.getParameterAnnotations();
                    for (int pi = 0; pi < params.length; pi++) {
                        MBeanParameterInfo param = params[pi];
                        Descriptor pd =
                                ImmutableDescriptor.union(param.getDescriptor(),
                                    descriptorFor(annots[pi]));
                        params[pi] = new MBeanParameterInfo(param.getName(),
                                param.getType(), param.getDescription(), pd);
                    }
                    op = new MBeanOperationInfo(op.getName(),
                            op.getDescription(), params, op.getReturnType(),
                            op.getImpact(), d);
                    if (!ops[i].equals(op))
                        ops[i] = op;
                }
            }

            Descriptor id = descriptorFor(getMBeanInterface());
            info = new MBeanInfo(info.getClassName(), info.getDescription(),
                    attrs, info.getConstructors(), ops, info.getNotifications(),
                    ImmutableDescriptor.union(id, info.getDescriptor()));
            super.cacheMBeanInfo(info);
        }

        private Descriptor descriptorFor(AnnotatedElement x) {
            Annotation[] annots = x.getAnnotations();
            return descriptorFor(annots);
        }

        private Descriptor descriptorFor(Annotation[] annots) {
            if (annots.length == 0)
                return ImmutableDescriptor.EMPTY_DESCRIPTOR;
            Map<String, Object> descriptorMap = new HashMap<String, Object>();
            for (Annotation a : annots) {
                Class<? extends Annotation> c = a.annotationType();
                Method[] elements = c.getMethods();
                for (Method element : elements) {
                    DescriptorKey key =
                        element.getAnnotation(DescriptorKey.class);
                    if (key != null) {
                        String name = key.value();
                        Object value;
                        try {
                            value = element.invoke(a);
                        } catch (Exception e) {
                            // we don't expect this
                            throw new RuntimeException(e);
                        }
                        Object oldValue = descriptorMap.put(name, value);
                        if (oldValue != null && !oldValue.equals(value)) {
                            final String msg =
                                "Inconsistent values for descriptor field " +
                                name + " from annotations: " + value + " :: " +
                                oldValue;
                            throw new IllegalArgumentException(msg);
                        }
                    }
                }
            }
            if (descriptorMap.isEmpty())
                return ImmutableDescriptor.EMPTY_DESCRIPTOR;
            else
                return new ImmutableDescriptor(descriptorMap);
        }

        private Method getMethod(String name, MBeanFeatureInfo... params) {
            Class<?> intf = getMBeanInterface();
            ClassLoader loader = intf.getClassLoader();
            Class[] classes = new Class[params.length];
            for (int i = 0; i < params.length; i++) {
                MBeanFeatureInfo param = params[i];
                Descriptor d = param.getDescriptor();
                String type = (String) d.getFieldValue("originalType");
                if (type == null) {
                    if (param instanceof MBeanAttributeInfo)
                        type = ((MBeanAttributeInfo) param).getType();
                    else
                        type = ((MBeanParameterInfo) param).getType();
                }
                Class<?> c = primitives.get(type);
                if (c == null) {
                    try {
                        c = Class.forName(type, false, loader);
                    } catch (ClassNotFoundException e) {
                        return null;
                    }
                }
                classes[i] = c;
            }
            try {
                return intf.getMethod(name, classes);
            } catch (Exception e) {
                return null;
            }
        }

        private static final Map<String, Class<?>> primitives =
                new HashMap<String, Class<?>>();
        static {
            for (Class<?> c :
                    new Class[] {boolean.class, byte.class, short.class,
                                 int.class, long.class, float.class,
                                 double.class, char.class, void.class}) {
                primitives.put(c.getName(), c);
            }
        }
    }
}