/*

 * Copyright (c) 2004, 2008, 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.

 */

/*

 * @test

 * @bug 5035217 6766173

 * @summary Test that MBean's RuntimeException is wrapped in

 * RuntimeMBeanException and (for Standard MBeans) that checked exceptions

 * are wrapped in MBeanException

 * @author Eamonn McManus

 * @compile MBeanExceptionTest.java

 * @run main MBeanExceptionTest

 */

import java.util.Collections;

import java.util.Set;

import javax.management.Attribute;

import javax.management.AttributeList;

import javax.management.DynamicMBean;

import javax.management.MBeanException;

import javax.management.MBeanInfo;

import javax.management.MBeanServer;

import javax.management.MBeanServerFactory;

import javax.management.ObjectName;

import javax.management.RuntimeMBeanException;

import javax.management.StandardMBean;

public class MBeanExceptionTest {

    public static void main(String[] args) throws Exception {

        System.out.println("Test that if an MBean throws RuntimeException " +

                           "it is wrapped in RuntimeMBeanException,");

        System.out.println("and if a Standard MBean throws Exception " +

                           "it is wrapped in MBeanException");

        MBeanServer mbs = MBeanServerFactory.newMBeanServer();

        Object standard = new Except();

        ObjectName standardName = new ObjectName(":name=Standard MBean");

        Object standardMBean =

            new StandardMBean(new Except(), ExceptMBean.class);

        ObjectName standardMBeanName =

            new ObjectName(":name=Instance of StandardMBean");

        Object dynamic = new DynamicExcept();

        ObjectName dynamicName = new ObjectName(":name=Dynamic MBean");

        mbs.registerMBean(standard, standardName);

        mbs.registerMBean(standardMBean, standardMBeanName);

        mbs.registerMBean(dynamic, dynamicName);

        int failures = 0;

        failures += test(mbs, standardName, true);

        failures += test(mbs, standardMBeanName, true);

        failures += test(mbs, dynamicName, false);

        final boolean[] booleans = {false, true};

        for (boolean runtimeX : booleans) {

            Class<? extends Exception> excC =

                    runtimeX ? RuntimeMBeanException.class : MBeanException.class;

            String excS =

                    runtimeX ? "a RuntimeMBeanException" : "an MBeanException";

            String mbsS = "a plain MBeanServer";

            System.out.println(

                    "Test that, with " + mbsS + ", " + excS + " is wrapped " +

                    "in " + excS);

            // E.g. "Test that, with a plain MBeanServer, an MBeanException

            // is wrapped in an MBeanException".

            try {

                mbs.createMBean(

                        Except.class.getName(), new ObjectName(":name=Oops"),

                        new Object[] {runtimeX},

                        new String[] {boolean.class.getName()});

                System.out.println(

                        "FAIL: createMBean succeeded but should not have");

                failures++;

            } catch (Exception e) {

                if (!excC.isInstance(e)) {

                    System.out.println(

                            "FAIL: expected " + excC.getName() + " from " +

                            "createMBean, got " + e);

                    failures++;

                } else {

                    Throwable cause = e.getCause();

                    if (!excC.isInstance(cause)) {

                        System.out.println(

                                "FAIL: expected " + excC.getName() +

                                " as cause of " + excC.getName() +

                                ", got " + e);

                        failures++;

                    } else

                        System.out.println("...ok");

                }

            }

        }

        if (failures == 0)

            System.out.println("Test passed");

        else {

            System.out.println("TEST FAILED: " + failures + " failure(s)");

            System.exit(1);

        }

    }

    private static int test(MBeanServer mbs, ObjectName name,

                            boolean testChecked)

            throws Exception {

        System.out.println("--------" + name + "--------");

        int failures = 0;

        final String[] ops = {"getAttribute", "setAttribute", "invoke"};

        final int GET = 0, SET = 1, INVOKE = 2;

        final String[] targets = {"UncheckedException", "CheckedException"};

        final int UNCHECKED = 0, CHECKED = 1;

        for (int i = 0; i < ops.length; i++) {

            for (int j = 0; j < targets.length; j++) {

                if (j == CHECKED && !testChecked)

                    continue;

                String target = targets[j];

                String what = ops[i] + "/" + target;

                System.out.println(what);

                try {

                    switch (i) {

                    case GET:

                        mbs.getAttribute(name, target);

                        break;

                    case SET:

                        mbs.setAttribute(name, new Attribute(target, "x"));

                        break;

                    case INVOKE:

                        mbs.invoke(name, target, null, null);

                        break;

                    default:

                        throw new AssertionError();

                    }

                    System.out.println("failure: " + what + " returned!");

                    failures++;

                } catch (RuntimeMBeanException e) {

                    if (j == CHECKED) {

                        System.out.println("failure: RuntimeMBeanException " +

                                           "when checked expected: " + e);

                        failures++;

                    } else {

                        Throwable cause = e.getCause();

                        if (cause == theUncheckedException)

                            System.out.println("ok: " + what);

                        else {

                            System.out.println("failure: " + what +

                                               " wrapped " + cause);

                            failures++;

                        }

                    }

                } catch (MBeanException e) {

                    if (j == UNCHECKED) {

                        System.out.println("failure: checked exception " +

                                           "when unchecked expected: " + e);

                        failures++;

                    } else {

                        Throwable cause = e.getCause();

                        if (cause == theCheckedException)

                            System.out.println("ok: " + what);

                        else {

                            System.out.println("failure: " + what +

                                               " wrapped " + cause);

                            failures++;

                        }

                    }

                } catch (Throwable t) {

                    System.out.println("failure: " + what + " threw: " + t);

                    while ((t = t.getCause()) != null)

                        System.out.println("  ... " + t);

                    failures++;

                }

            }

        }

        return failures;

    }

    public static interface ExceptMBean {

        public String getUncheckedException();

        public void setUncheckedException(String x);

        public void UncheckedException();

        public String getCheckedException() throws Exception;

        public void setCheckedException(String x) throws Exception;

        public void CheckedException() throws Exception;

    }

    public static class Except implements ExceptMBean {

        public Except() {}

        public Except(boolean runtimeX) throws MBeanException {

            if (runtimeX)

                throw new RuntimeMBeanException(new RuntimeException(), "Bang");

            else

                throw new MBeanException(new Exception(), "Bang");

        }

        public String getUncheckedException() {

            throw theUncheckedException;

        }

        public void setUncheckedException(String x) {

            throw theUncheckedException;

        }

        public void UncheckedException() {

            throw theUncheckedException;

        }

        public String getCheckedException() throws Exception {

            throw theCheckedException;

        }

        public void setCheckedException(String x) throws Exception {

            throw theCheckedException;

        }

        public void CheckedException() throws Exception {

            throw theCheckedException;

        }

    }

    public static class DynamicExcept implements DynamicMBean {

        public Object getAttribute(String attrName)

                throws MBeanException {

            if (attrName.equals("UncheckedException"))

                throw theUncheckedException;

            else

                throw new AssertionError();

        }

        public void setAttribute(Attribute attr)

                throws MBeanException {

            String attrName = attr.getName();

            if (attrName.equals("UncheckedException"))

                throw theUncheckedException;

            else

                throw new AssertionError();

        }

        public Object invoke(String opName, Object[] params, String[] sig)

                throws MBeanException {

            assert params == null && sig == null;

            if (opName.equals("UncheckedException"))

                throw theUncheckedException;

            else

                throw new AssertionError();

        }

        public AttributeList getAttributes(String[] names) {

            assert false;

            return null;

        }

        public AttributeList setAttributes(AttributeList attrs) {

            assert false;

            return null;

        }

        public MBeanInfo getMBeanInfo() {

            try {

                return new StandardMBean(new Except(), ExceptMBean.class)

                    .getMBeanInfo();

            } catch (Exception e) {

                assert false;

                return null;

            }

        }

    }

    private static final Exception theCheckedException =

        new Exception("The checked exception that should be seen");

    private static final RuntimeException theUncheckedException =

        new UnsupportedOperationException("The unchecked exception " +

                                          "that should be seen");

}