1 /*
2 * Copyright (c) 2004, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 /*
25 * @test
26 * @bug 5035217 6766173
27 * @summary Test that MBean's RuntimeException is wrapped in
28 * RuntimeMBeanException and (for Standard MBeans) that checked exceptions
29 * are wrapped in MBeanException
30 * @author Eamonn McManus
31 * @modules java.management
32 * @compile MBeanExceptionTest.java
33 * @run main MBeanExceptionTest
34 */
35
36 import java.util.Collections;
37 import java.util.Set;
38 import javax.management.Attribute;
39 import javax.management.AttributeList;
40 import javax.management.DynamicMBean;
41 import javax.management.MBeanException;
42 import javax.management.MBeanInfo;
43 import javax.management.MBeanServer;
44 import javax.management.MBeanServerFactory;
45 import javax.management.ObjectName;
46 import javax.management.RuntimeMBeanException;
47 import javax.management.StandardMBean;
48
49 public class MBeanExceptionTest {
50 public static void main(String[] args) throws Exception {
51 System.out.println("Test that if an MBean throws RuntimeException " +
52 "it is wrapped in RuntimeMBeanException,");
53 System.out.println("and if a Standard MBean throws Exception " +
54 "it is wrapped in MBeanException");
55 MBeanServer mbs = MBeanServerFactory.newMBeanServer();
56 Object standard = new Except();
57 ObjectName standardName = new ObjectName(":name=Standard MBean");
58 Object standardMBean =
59 new StandardMBean(new Except(), ExceptMBean.class);
60 ObjectName standardMBeanName =
61 new ObjectName(":name=Instance of StandardMBean");
62 Object dynamic = new DynamicExcept();
63 ObjectName dynamicName = new ObjectName(":name=Dynamic MBean");
64 mbs.registerMBean(standard, standardName);
65 mbs.registerMBean(standardMBean, standardMBeanName);
66 mbs.registerMBean(dynamic, dynamicName);
67 int failures = 0;
68 failures += test(mbs, standardName, true);
69 failures += test(mbs, standardMBeanName, true);
70 failures += test(mbs, dynamicName, false);
71
72 final boolean[] booleans = {false, true};
73
74 for (boolean runtimeX : booleans) {
75 Class<? extends Exception> excC =
76 runtimeX ? RuntimeMBeanException.class : MBeanException.class;
77 String excS =
78 runtimeX ? "a RuntimeMBeanException" : "an MBeanException";
79 String mbsS = "a plain MBeanServer";
80 System.out.println(
81 "Test that, with " + mbsS + ", " + excS + " is wrapped " +
82 "in " + excS);
83 // E.g. "Test that, with a plain MBeanServer, an MBeanException
84 // is wrapped in an MBeanException".
85 try {
86 mbs.createMBean(
87 Except.class.getName(), new ObjectName(":name=Oops"),
88 new Object[] {runtimeX},
89 new String[] {boolean.class.getName()});
90 System.out.println(
91 "FAIL: createMBean succeeded but should not have");
92 failures++;
93 } catch (Exception e) {
94 if (!excC.isInstance(e)) {
95 System.out.println(
96 "FAIL: expected " + excC.getName() + " from " +
97 "createMBean, got " + e);
98 failures++;
99 } else {
100 Throwable cause = e.getCause();
101 if (!excC.isInstance(cause)) {
102 System.out.println(
103 "FAIL: expected " + excC.getName() +
104 " as cause of " + excC.getName() +
105 ", got " + e);
106 failures++;
107 } else
108 System.out.println("...ok");
109 }
110 }
111 }
112
113 if (failures == 0)
114 System.out.println("Test passed");
115 else {
116 System.out.println("TEST FAILED: " + failures + " failure(s)");
117 System.exit(1);
118 }
119 }
120
121 private static int test(MBeanServer mbs, ObjectName name,
122 boolean testChecked)
123 throws Exception {
124 System.out.println("--------" + name + "--------");
125
126 int failures = 0;
127 final String[] ops = {"getAttribute", "setAttribute", "invoke"};
128 final int GET = 0, SET = 1, INVOKE = 2;
129 final String[] targets = {"UncheckedException", "CheckedException"};
130 final int UNCHECKED = 0, CHECKED = 1;
131
132 for (int i = 0; i < ops.length; i++) {
133 for (int j = 0; j < targets.length; j++) {
134
135 if (j == CHECKED && !testChecked)
136 continue;
137
138 String target = targets[j];
139 String what = ops[i] + "/" + target;
140 System.out.println(what);
141
142 try {
143 switch (i) {
144 case GET:
145 mbs.getAttribute(name, target);
146 break;
147 case SET:
148 mbs.setAttribute(name, new Attribute(target, "x"));
149 break;
150 case INVOKE:
151 mbs.invoke(name, target, null, null);
152 break;
153 default:
154 throw new AssertionError();
155 }
156 System.out.println("failure: " + what + " returned!");
157 failures++;
158 } catch (RuntimeMBeanException e) {
159 if (j == CHECKED) {
160 System.out.println("failure: RuntimeMBeanException " +
161 "when checked expected: " + e);
162 failures++;
163 } else {
164 Throwable cause = e.getCause();
165 if (cause == theUncheckedException)
166 System.out.println("ok: " + what);
167 else {
168 System.out.println("failure: " + what +
169 " wrapped " + cause);
170 failures++;
171 }
172 }
173 } catch (MBeanException e) {
174 if (j == UNCHECKED) {
175 System.out.println("failure: checked exception " +
176 "when unchecked expected: " + e);
177 failures++;
178 } else {
179 Throwable cause = e.getCause();
180 if (cause == theCheckedException)
181 System.out.println("ok: " + what);
182 else {
183 System.out.println("failure: " + what +
184 " wrapped " + cause);
185 failures++;
186 }
187 }
188 } catch (Throwable t) {
189 System.out.println("failure: " + what + " threw: " + t);
190 while ((t = t.getCause()) != null)
191 System.out.println(" ... " + t);
192 failures++;
193 }
194 }
195 }
196
197 return failures;
198 }
199
200 public static interface ExceptMBean {
201 public String getUncheckedException();
202 public void setUncheckedException(String x);
203 public void UncheckedException();
204 public String getCheckedException() throws Exception;
205 public void setCheckedException(String x) throws Exception;
206 public void CheckedException() throws Exception;
207 }
208
209 public static class Except implements ExceptMBean {
210 public Except() {}
211
212 public Except(boolean runtimeX) throws MBeanException {
213 if (runtimeX)
214 throw new RuntimeMBeanException(new RuntimeException(), "Bang");
215 else
216 throw new MBeanException(new Exception(), "Bang");
217 }
218
219 public String getUncheckedException() {
220 throw theUncheckedException;
221 }
222 public void setUncheckedException(String x) {
223 throw theUncheckedException;
224 }
225 public void UncheckedException() {
226 throw theUncheckedException;
227 }
228 public String getCheckedException() throws Exception {
229 throw theCheckedException;
230 }
231 public void setCheckedException(String x) throws Exception {
232 throw theCheckedException;
233 }
234 public void CheckedException() throws Exception {
235 throw theCheckedException;
236 }
237 }
238
239 public static class DynamicExcept implements DynamicMBean {
240 public Object getAttribute(String attrName)
241 throws MBeanException {
242 if (attrName.equals("UncheckedException"))
243 throw theUncheckedException;
244 else
245 throw new AssertionError();
246 }
247 public void setAttribute(Attribute attr)
248 throws MBeanException {
249 String attrName = attr.getName();
250 if (attrName.equals("UncheckedException"))
251 throw theUncheckedException;
252 else
253 throw new AssertionError();
254 }
255 public Object invoke(String opName, Object[] params, String[] sig)
256 throws MBeanException {
257 assert params == null && sig == null;
258 if (opName.equals("UncheckedException"))
259 throw theUncheckedException;
260 else
261 throw new AssertionError();
262 }
263 public AttributeList getAttributes(String[] names) {
264 assert false;
265 return null;
266 }
267 public AttributeList setAttributes(AttributeList attrs) {
268 assert false;
269 return null;
270 }
271 public MBeanInfo getMBeanInfo() {
272 try {
273 return new StandardMBean(new Except(), ExceptMBean.class)
274 .getMBeanInfo();
275 } catch (Exception e) {
276 assert false;
277 return null;
278 }
279 }
280 }
281
282 private static final Exception theCheckedException =
283 new Exception("The checked exception that should be seen");
284 private static final RuntimeException theUncheckedException =
285 new UnsupportedOperationException("The unchecked exception " +
286 "that should be seen");
287 }