/*
 * Copyright 2007 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 6252592 4967755
 * @summary Check that default fields are correctly added to Descriptors
 * and that input Descriptors are never modified
 * @author Lars Westergren
 */

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import javax.management.Descriptor;
import javax.management.IntrospectionException;
import javax.management.MBeanAttributeInfo;
import javax.management.MBeanConstructorInfo;
import javax.management.MBeanException;
import javax.management.MBeanNotificationInfo;
import javax.management.MBeanOperationInfo;
import javax.management.RuntimeOperationsException;
import javax.management.modelmbean.DescriptorSupport;
import javax.management.modelmbean.ModelMBeanAttributeInfo;
import javax.management.modelmbean.ModelMBeanConstructorInfo;
import javax.management.modelmbean.ModelMBeanInfo;
import javax.management.modelmbean.ModelMBeanInfoSupport;
import javax.management.modelmbean.ModelMBeanNotificationInfo;
import javax.management.modelmbean.ModelMBeanOperationInfo;

/**
 * Junit tests for bugs:
 * 6252592 Provide for the user mandatory fields missing in Descriptor given
 *         to Model*Info constructors
 * 4967755 ModelMBeanAttributeInfo constructor modifies its Descriptor argument
 *
 * @author Lars Westergren
 */
public class DefaultDescriptorFieldTest /*extends TestCase*/ {
    public static void main(String[] args) throws Exception {
        boolean fail = false;
        Object test = new DefaultDescriptorFieldTest("Test");
        for (Method m : DefaultDescriptorFieldTest.class.getMethods()) {
            if (m.getName().startsWith("test") &&
                    m.getParameterTypes().length == 0) {
                System.out.println("Testing " + m.getName());
                try {
                    m.invoke(test);
                } catch (InvocationTargetException e) {
                    fail = true;
                    Throwable t = e.getCause();
                    System.out.println("FAILED: exception: " + t);
                    t.printStackTrace(System.out);
                }
            }
        }
        if (fail)
            throw new Exception("TEST FAILED");
    }

    //No check WHICH constructor is reflected, at least when the classes tested are constructed,
    //so I just use first one that came to mind.
    final Constructor[] constArr = String.class.getConstructors();
    final Constructor dummyConstructor = constArr[0];


    Method getMethod = null;

    /** Creates a new instance of MBeanTest */
    public DefaultDescriptorFieldTest(final String name) {
        try {
            getMethod = String.class.getMethod("toString");
        } catch (SecurityException ex) {
            ex.printStackTrace();
        } catch (NoSuchMethodException ex) {
            ex.printStackTrace();
        }
    }

    /**
     * Test instantiating the 5 different classes with a null
     * Descriptor, and also setting a null descriptor after.
     * Expected: Default Descriptors created.
     */
    public void testNullDescriptors()
    throws IntrospectionException, MBeanException {
        final ModelMBeanConstructorInfo constInfo =
                new ModelMBeanConstructorInfo("Dummy", dummyConstructor, null);
        constInfo.setDescriptor(null);
        ModelMBeanAttributeInfo attInfo =
                new ModelMBeanAttributeInfo("dummyAttInfoName", "dummyAttInfoDesc", getMethod, null, null);
        attInfo.setDescriptor(null);
        ModelMBeanNotificationInfo notInfo =
                new ModelMBeanNotificationInfo(null, "notificationClassName", "daName", null);
        notInfo.setDescriptor(null);
        ModelMBeanOperationInfo opInfo =
                new ModelMBeanOperationInfo("test", getMethod, null);
        opInfo.setDescriptor(null);
        ModelMBeanInfoSupport infoSupport =
                new ModelMBeanInfoSupport(new DummyModelMBeanInfo());
        infoSupport.setDescriptor(null,null);
        infoSupport.setDescriptor(null, "mbean");
    }

    /**
     * Test instantiating and setting a Descriptor without the "name",
     * "descriptorType" or "role" fields. This also tests whether the
     * Descriptor is cloned before default values are set, since
     * default values for one class will be incorrect for the next.
     * Expected: Descriptor should be cloned, missing default values should be
     * set
     */
    public void testFieldlessDescriptor()
    throws IntrospectionException, MBeanException {
        Descriptor theNamelessOne = new DescriptorSupport();
        final ModelMBeanConstructorInfo constInfo =
                new ModelMBeanConstructorInfo("Dummy", dummyConstructor, theNamelessOne);
        constInfo.setDescriptor(theNamelessOne);
        ModelMBeanAttributeInfo attInfo =
                new ModelMBeanAttributeInfo("dummyAttInfoName", "dummyAttInfoDesc", getMethod, null, theNamelessOne);
        attInfo.setDescriptor(theNamelessOne);
        ModelMBeanNotificationInfo notInfo =
                new ModelMBeanNotificationInfo(null, "notificationClassName", "daName", theNamelessOne);
        notInfo.setDescriptor(theNamelessOne);
        ModelMBeanOperationInfo opInfo =
                new ModelMBeanOperationInfo("test", getMethod, theNamelessOne);
        opInfo.setDescriptor(theNamelessOne);
        ModelMBeanInfoSupport infoSupport = new ModelMBeanInfoSupport(new DummyModelMBeanInfo());
        infoSupport.setDescriptor(theNamelessOne, null);
        infoSupport.setDescriptor(theNamelessOne, "mbean");
    }


     /**
     * Creates an empty DescriptorSupport and then test that ModelMBeanConstructorInfo accepts
      * the correct fields in validation one by one.
     */
    public void testCorrectConstructorDescriptors()
    throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        Descriptor cDesc = new DescriptorSupport(new String[0],new String[0]);
        final ModelMBeanConstructorInfo constInfo =
                new ModelMBeanConstructorInfo("Dummy", dummyConstructor, cDesc);
        assertFalse(fieldRefuted(constInfo, cDesc, "name" , "java.lang.String"));
        assertFalse(fieldRefuted(constInfo, cDesc, "role" , "constructor"));
        assertFalse(fieldRefuted(constInfo, cDesc, "descriptorType" , "operation"));
    }

    /**
     * Test that ModelMBeanConstructorInfo refutes incorrect fields in validation one by one.
     */
    public void testIncorrectConstructorDescriptors()
    throws NoSuchMethodException, IllegalAccessException {
        Descriptor cDesc = new DescriptorSupport(
           new String[] {"getMethod", "setMethod", "role", "Class", "name", "descriptorType"},
           new String[] {"dummyGetMethod", "dummySetMethod", "constructor", "dummyClass", "java.lang.String", "operation"});
        final ModelMBeanConstructorInfo constInfo = new ModelMBeanConstructorInfo("Dummy", dummyConstructor, cDesc);
        assertTrue(fieldRefuted(constInfo, cDesc, "name" , "blah"));
        assertTrue(fieldRefuted(constInfo, cDesc, "descriptorType", "mbean"));
        assertTrue(fieldRefuted(constInfo, cDesc, "descriptorType", "notification"));
        assertTrue(fieldRefuted(constInfo, cDesc, "descriptorType", "constructor"));
        assertTrue(fieldRefuted(constInfo, cDesc, "role", "operation"));
    }

    public void testCorrectAttributeDescriptors()
    throws IntrospectionException, NoSuchMethodException, IllegalAccessException {
        Descriptor aDesc = new DescriptorSupport(new String[0],new String[0]);
        final ModelMBeanAttributeInfo attInfo = new ModelMBeanAttributeInfo("dummyAttInfoName", "dummyAttInfoDesc", getMethod, null, null);
        assertFalse(fieldRefuted(attInfo, aDesc, "name" , "dummyAttInfoName"));
        assertFalse(fieldRefuted(attInfo, aDesc, "descriptorType" , "attribute"));
    }

    public void testIncorrectAttributeDescriptors()
    throws IntrospectionException, NoSuchMethodException, IllegalAccessException {
        Descriptor aDesc = new DescriptorSupport();
        final ModelMBeanAttributeInfo attInfo = new ModelMBeanAttributeInfo("dummyAttInfoName", "dummyAttInfoDesc", getMethod, null, null);
        assertTrue(fieldRefuted(attInfo, aDesc, "name" , "blah"));
        assertTrue(fieldRefuted(attInfo, aDesc, "descriptorType" , "constructor"));
        assertTrue(fieldRefuted(attInfo, aDesc, "descriptorType" , "notification"));
    }

    public void testCorrectNotificationDescriptors()
    throws NoSuchMethodException, IllegalAccessException  {
        Descriptor nDesc = new DescriptorSupport();
        final ModelMBeanNotificationInfo nInfo = new ModelMBeanNotificationInfo(null, "notificationClassName", "daName", nDesc);
        assertFalse(fieldRefuted(nInfo, nDesc, "name" , "notificationClassName"));
        assertFalse(fieldRefuted(nInfo, nDesc, "descriptorType" , "notification"));
    }

    public void testIncorrectNotificationDescriptors()
    throws NoSuchMethodException, IllegalAccessException {
        Descriptor nDesc = new DescriptorSupport();
        final ModelMBeanNotificationInfo nInfo = new ModelMBeanNotificationInfo(null, "notificationClassName", "daName", nDesc);
        assertTrue(fieldRefuted(nInfo, nDesc, "name" , "blah"));
        assertTrue(fieldRefuted(nInfo, nDesc, "descriptorType" , "constructor"));
        assertTrue(fieldRefuted(nInfo, nDesc, "descriptorType" , "operation"));
    }

    public void testCorrectOperationDescriptors()
    throws NoSuchMethodException, IllegalAccessException {
        Descriptor opDesc = new DescriptorSupport();
        final ModelMBeanOperationInfo opInfo = new ModelMBeanOperationInfo("test", "readable description", null, "type", 1, opDesc);
        assertFalse(fieldRefuted(opInfo, opDesc, "name" , "test"));
        assertFalse(fieldRefuted(opInfo, opDesc, "descriptorType" , "operation"));
        assertFalse(fieldRefuted(opInfo, opDesc, "role" , "operation"));
        assertFalse(fieldRefuted(opInfo, opDesc, "role" , "getter"));
        assertFalse(fieldRefuted(opInfo, opDesc, "role" , "setter"));
    }

    public void testIncorrectOperationDescriptors()
    throws NoSuchMethodException, IllegalAccessException {
        Descriptor opDesc = new DescriptorSupport();
        final ModelMBeanOperationInfo opInfo = new ModelMBeanOperationInfo("test", "readable description", null, "type", 1, opDesc);
        assertTrue(fieldRefuted(opInfo, opDesc, "name" , "DENIED!!"));
        assertTrue(fieldRefuted(opInfo, opDesc, "descriptorType" , "constructor"));
        assertTrue(fieldRefuted(opInfo, opDesc, "descriptorType" , "attribute"));
        assertTrue(fieldRefuted(opInfo, opDesc, "descriptorType" , "notification"));
        assertTrue(fieldRefuted(opInfo, opDesc, "descriptorType" , "x"));
    }

    //TODO also test ModelMBeanInfoSupport perhaps. Slightly more difficult to set up and test.

    /**
     * Clones descriptor, sets a new value in the clone and tries to apply clone to
     * reflected Model*Info object method. The new field should be refuted if it
     * is a bad value.
     */
    //I like java, but this is one case where duck typing would have been slightly easier I think. :)
    private boolean fieldRefuted(Object mbeanInfo, Descriptor desc, String fieldName, String newValue)
    throws NoSuchMethodException, IllegalAccessException {
        Method setDescMethod = mbeanInfo.getClass().getMethod("setDescriptor", Descriptor.class);
        Descriptor newDesc = (Descriptor)desc.clone();
        boolean refused = false;
        newDesc.setField(fieldName, newValue);
        try {
            setDescMethod.invoke(mbeanInfo, newDesc);
        } catch (InvocationTargetException ex) {
            //If we get classcast exception, someone passed in a bad object to reflection.
            //Perhaps an unnecessary check, this cast?
            RuntimeOperationsException rex = (RuntimeOperationsException)ex.getTargetException();
            refused = true;
        }
        return refused;
    }

    /**
     * Dummy class used to create test objects. May not be needed.
     */
   private class DummyModelMBeanInfo implements ModelMBeanInfo {
            public Descriptor[] getDescriptors(String inDescriptorType)
            throws MBeanException, RuntimeOperationsException {
                return null;
            }

            public void setDescriptors(Descriptor[] inDescriptors)
            throws MBeanException, RuntimeOperationsException {

            }

            public Descriptor getDescriptor(String inDescriptorName, String inDescriptorType)
            throws MBeanException, RuntimeOperationsException {
                return null;
            }

            public void setDescriptor(Descriptor inDescriptor, String inDescriptorType)
            throws MBeanException, RuntimeOperationsException {

            }

            public Descriptor getMBeanDescriptor()
            throws MBeanException, RuntimeOperationsException {
                return null;
            }

            public void setMBeanDescriptor(Descriptor inDescriptor)
            throws MBeanException, RuntimeOperationsException {

            }

            public ModelMBeanAttributeInfo getAttribute(String inName)
            throws MBeanException, RuntimeOperationsException {
                return null;
            }

            public ModelMBeanOperationInfo getOperation(String inName)
            throws MBeanException, RuntimeOperationsException {
                return null;
            }

            public ModelMBeanNotificationInfo getNotification(String inName)
            throws MBeanException, RuntimeOperationsException {
                return null;
            }

            public MBeanAttributeInfo[] getAttributes() {
                return null;
            }

            public String getClassName() {
                return "AnonMBeanInfoImpl";
            }

            public MBeanConstructorInfo[] getConstructors() {
                return null;
            }

            public String getDescription() {
                return null;
            }

            public MBeanNotificationInfo[] getNotifications() {
                return null;
            }

            public MBeanOperationInfo[] getOperations() {
                return null;
            }

            public Object clone() {
                return null;

            }

    }

    private static void assertFalse(boolean x) {
        assertTrue(!x);
    }

    private static void assertTrue(boolean x) {
        if (!x)
            throw new AssertionError("Assertion failed");
    }

}