/*
* 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");
}
