|
1
22 package org.jboss.test.jmx.compliance.openmbean;
23
24 import java.io.ByteArrayInputStream  ;
25 import java.io.ByteArrayOutputStream ;
26 import java.io.ObjectInputStream ;
27 import java.io.ObjectOutputStream ;
28 import java.util.Arrays ;
29 import java.util.List ;
30
31 import javax.management.openmbean.OpenDataException ;
32 import javax.management.openmbean.OpenType ;
33
34 import junit.framework.TestCase;
35
36
41 public class OpenTypeTestCase
42 extends TestCase
43 {
44
46
48
51 public OpenTypeTestCase(String s)
52 {
53 super(s);
54 }
55
56
58
61 public void testAllowedClasses()
62 throws Exception
63 {
64 String [] allowedClassNames = OpenType.ALLOWED_CLASSNAMES;
65 assertEquals(16, allowedClassNames.length);
66 List names = Arrays.asList(allowedClassNames);
67 checkOpenType(names, java.lang.Void .class);
68 checkOpenType(names, java.lang.Boolean .class);
69 checkOpenType(names, java.lang.Character .class);
70 checkOpenType(names, java.lang.Byte .class);
71 checkOpenType(names, java.lang.Short .class);
72 checkOpenType(names, java.lang.Integer .class);
73 checkOpenType(names, java.lang.Long .class);
74 checkOpenType(names, java.lang.Float .class);
75 checkOpenType(names, java.lang.Double .class);
76 checkOpenType(names, java.lang.String .class);
77 checkOpenType(names, java.util.Date .class);
78 checkOpenType(names, java.math.BigDecimal .class);
79 checkOpenType(names, java.math.BigInteger .class);
80 checkOpenType(names, javax.management.ObjectName .class);
81 checkOpenType(names, javax.management.openmbean.CompositeData .class);
82 checkOpenType(names, javax.management.openmbean.TabularData .class);
83 }
84
85 public void testConstructorSimple()
86 throws Exception
87 {
88 OpenType test = new MyOpenType("java.lang.Void", "type", "description");
89 assertEquals("java.lang.Void", test.getClassName());
90 assertEquals("type", test.getTypeName());
91 assertEquals("description", test.getDescription());
92 assertEquals(false, test.isArray());
93 }
94
95 public void testConstructorArray()
96 throws Exception
97 {
98 OpenType test = new MyOpenType("[[Ljava.lang.Void;", "type", "description");
99 assertEquals("[[Ljava.lang.Void;", test.getClassName());
100 assertEquals("type", test.getTypeName());
101 assertEquals("description", test.getDescription());
102 assertEquals(true, test.isArray());
103 }
104
105 public void testSerializationSimple()
106 throws Exception
107 {
108 testSerialization("java.lang.Void", "type", "description");
109 }
110
111 public void testSerializationArray()
112 throws Exception
113 {
114 testSerialization("[[Ljava.lang.Void;", "type", "description");
115 }
116
117
120 public void testErrors()
121 throws Exception
122 {
123 boolean caught = false;
124 try
125 {
126 new MyOpenType(null, "dummy", "dummy");
127 }
128 catch (IllegalArgumentException e)
129 {
130 caught = true;
131 }
132 assertTrue("className cannot be null", caught);
133
134 caught = false;
135 try
136 {
137 new MyOpenType("", "dummy", "dummy");
138 }
139 catch (IllegalArgumentException e)
140 {
141 caught = true;
142 }
143 assertTrue("className cannot be empty", caught);
144
145 caught = false;
146 try
147 {
148 new MyOpenType("java.lang.Void", null, "dummy");
149 }
150 catch (IllegalArgumentException e)
151 {
152 caught = true;
153 }
154 assertTrue("typeName cannot be null", caught);
155
156 caught = false;
157 try
158 {
159 new MyOpenType("java.lang.Void", null, "dummy");
160 }
161 catch (IllegalArgumentException e)
162 {
163 caught = true;
164 }
165 assertTrue("typeName cannot be empty", caught);
166
167 caught = false;
168 try
169 {
170 new MyOpenType("java.lang.Void", "dummy", null);
171 }
172 catch (IllegalArgumentException e)
173 {
174 caught = true;
175 }
176 assertTrue("description cannot be null", caught);
177
178 caught = false;
179 try
180 {
181 new MyOpenType("java.lang.Void", "dummy", "");
182 }
183 catch (IllegalArgumentException e)
184 {
185 caught = true;
186 }
187 assertTrue("description cannot be empty", caught);
188
189 caught = false;
190 try
191 {
192 new MyOpenType("java.lang.Class", "dummy", "dummy");
193 }
194 catch (OpenDataException e)
195 {
196 caught = true;
197 }
198 assertTrue("className must be an OpenDataType", caught);
199
200 caught = false;
201 try
202 {
203 new MyOpenType("[Ljava.lang.Void", "dummy", "dummy");
204 }
205 catch (OpenDataException e)
206 {
207 caught = true;
208 }
209 assertTrue("[Ljava.lang.Void is not a valid array", caught);
210 }
211
212
215 public void testErrors2()
216 throws Exception
217 {
218 boolean caught = false;
219 try
220 {
221 new MyOpenType("[L", "dummy", "dummy");
222 }
223 catch (StringIndexOutOfBoundsException e)
224 {
225 fail("FAILS IN RI: [L open type should be an OpenDataException not a StringIndexOutOfBoundsException");
226 }
227 catch (OpenDataException e)
228 {
229 caught = true;
230 }
231 assertTrue("[L is not a valid array", caught);
232 }
233
234
237 public void testErrors3()
238 throws Exception
239 {
240 boolean caught = false;
241 try
242 {
243 new MyOpenType("[Xjava.lang.Void;", "dummy", "dummy");
244 }
245 catch (OpenDataException e)
246 {
247 caught = true;
248 }
249 assertTrue("FAILS IN RI: [Xjava.lang.Void; is not a valid array", caught);
250 }
251
252
254 private void checkOpenType(List names, Class clazz)
255 throws Exception
256 {
257 String name = clazz.getName();
258 assertTrue(name + " is an OpenType", names.contains(name));
259
260 new MyOpenType(name, "dummy", "dummy");
261
262 new MyOpenType("[L"+name+";", "dummy", "dummy");
263
264 new MyOpenType("[[[[[L"+name+";", "dummy", "dummy");
265 }
266
267 private void testSerialization(String className, String type, String description)
268 throws Exception
269 {
270 OpenType original = new MyOpenType(className, type, description);
272
273 ByteArrayOutputStream baos = new ByteArrayOutputStream ();
275 ObjectOutputStream oos = new ObjectOutputStream (baos);
276 oos.writeObject(original);
277
278 ByteArrayInputStream bais = new ByteArrayInputStream (baos.toByteArray());
280 ObjectInputStream ois = new ObjectInputStream (bais);
281 OpenType result = (OpenType ) ois.readObject();
282
283 assertEquals(original.getClassName(), result.getClassName());
285 assertEquals(original.getTypeName(), result.getTypeName());
286 assertEquals(original.getDescription(), result.getDescription());
287 assertEquals(original.isArray(), result.isArray());
288 }
289
290 public static class MyOpenType
291 extends OpenType
292 {
293 private static final long serialVersionUID = -1;
294
295 public MyOpenType(String className, String typeName, String description)
296 throws OpenDataException
297 {
298 super(className, typeName, description);
299 }
300 public boolean equals(Object other)
301 {
302 throw new UnsupportedOperationException ("irrelevent");
303 }
304 public int hashCode()
305 {
306 throw new UnsupportedOperationException ("irrelevent");
307 }
308 public boolean isValue(Object other)
309 {
310 throw new UnsupportedOperationException ("irrelevent");
311 }
312 public String toString()
313 {
314 throw new UnsupportedOperationException ("irrelevent");
315 }
316 }
317 }
318 |
Popular Tags |
Java API By Example, From Geeks To Geeks.