/* * Copyright (c) 2004, 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. */ /* * @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 * * @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 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"); }