|
1
8
9 package test.javax.management.modelmbean;
10
11 import java.io.ByteArrayInputStream  ;
12 import java.io.ByteArrayOutputStream ;
13 import java.io.ObjectInputStream ;
14 import java.io.ObjectOutputStream ;
15 import java.util.ArrayList ;
16 import java.util.Arrays ;
17 import java.util.HashSet ;
18 import java.util.Iterator ;
19 import java.util.List ;
20 import java.util.Set ;
21 import javax.management.Descriptor ;
22 import javax.management.RuntimeOperationsException ;
23 import javax.management.modelmbean.DescriptorSupport ;
24 import javax.management.modelmbean.XMLParseException ;
25
26 import test.MX4JTestCase;
27
28
31
32 public class DescriptorSupportTest extends MX4JTestCase
33 {
34 public DescriptorSupportTest(String s)
35 {
36 super(s);
37 }
38
39 public void testValid() throws Exception
40 {
41 String [] attributes = {"name=mytest", "descriptorType=MBean", "role=constructor"};
43 new DescriptorSupport (attributes);
44
45 String [] names = {"name", "descriptorType", "role", "persistPolicy", "persistPeriod"};
47 String [] values = {"mytest", "MBean", "constructor", "Never", "1"};
48 new DescriptorSupport (names, values);
49
50 names = new String []{"name", "descriptorType", "persistPolicy"};
52 values = new String []{"mytest", "MBean", "never"};
53
54 new DescriptorSupport (names, values);
55 }
56
57 public void testInvalid() throws Exception
58 {
59 String [] names = {"name", "descriptorType", "role", "persistPolicy"};
61 String [] values = {"mytest", "MBean", "constructor", "Something"};
62
63 try
64 {
65 new DescriptorSupport (names, values);
66 fail("Descriptor support object created with invalid attributes");
67 }
68 catch (RuntimeOperationsException ex)
69 {
70 }
71
72 names = new String []{"name", "descriptorType", "persistPolicy", "persistPeriod"};
75 values = new String []{"mytest", "MBean", "Never", "-2"};
76
77 try
78 {
79 new DescriptorSupport (names, values);
80 fail("Descriptor support object created with invalid persistPeriod");
81 }
82 catch (RuntimeOperationsException ex)
83 {
84 }
85
86 names = new String []{"name", "descriptorType", "visibility"};
89 values = new String []{"mytest", "MBean", "0"};
90
91 try
92 {
93 new DescriptorSupport (names, values);
94 fail("Descriptor support object created with invalid visiblity");
95 }
96 catch (RuntimeOperationsException ex)
97 {
98 }
99
100 names = new String []{"name", "descriptorType", "visibility"};
103 values = new String []{"mytest", "MBean", "5"};
104
105 try
106 {
107 new DescriptorSupport (names, values);
108 fail("Descriptor support object created with invalid visiblity");
109 }
110 catch (RuntimeOperationsException ex)
111 {
112 }
113 }
114
115 public void testIsValid() throws Exception
116 {
117 String [] names = {"name", "descriptorType", "persistPolicy", "persistPeriod"};
119 String [] values = {"test", "mbean", "AlwaYs", "-1"};
120
121 DescriptorSupport ds = new DescriptorSupport (names, values);
122
123 assertTrue(ds.isValid());
124 }
125
126 public void testSeverityField() throws Exception
127 {
128 String [] names = {"name", "descriptorType", "severity"};
130 String [] values = {"test", "mbean", "0"};
131
132 DescriptorSupport ds = new DescriptorSupport (names, values);
133 assertTrue(ds.isValid());
134
135 names = new String []{"name", "descriptorType", "severity"};
136 values = new String []{"test", "mbean", "6"};
137
138 ds = new DescriptorSupport (names, values);
139 assertTrue(ds.isValid());
140 }
141
142 public void testCaseInsensitiveFieldNames() throws Exception
143 {
144 String [] fields = {"descriptorType", "myField"};
145 Object [] values = {"MBean", "top secret"};
146 DescriptorSupport ds = new DescriptorSupport (fields, values);
147 assertEquals("Expecting 'descriptorType' value to be 'mbean'", (String )ds.getFieldValue("DESCRIPTORTYPE"), "MBean");
148 assertEquals("Expecting 'myField' value to be 'top secret'", (String )ds.getFieldValue("MYfIELD"), "top secret");
149
150 fields = new String []{"name", "descriptorType", "deleteMe"};
151 values = new String []{"testCaseInsensitiveFieldNames", "MBean", "nothing of consequence"};
152 ds = new DescriptorSupport (fields, values);
153 ds.removeField("DELETEmE");
154 String [] fieldnames = ds.getFields();
155 List fieldlist = new ArrayList ();
156 for (int i = 0; i < fieldnames.length; i++) fieldlist.add(fieldnames[i]);
157 int fieldcount = fieldnames.length;
158 assertEquals("Expecting 'deleteMe' to be gone", fieldcount, 2);
159 assertFalse(fieldlist.contains("deleteme"));
160 }
161
162 public void testCaseInsensitiveFieldValues() throws Exception
163 {
164 String [] fields = {"descriptorType", "persistPolicy", "log"};
165 String [] values = {"mBEAN", "oNuPDATE", "TRUE"};
166 new DescriptorSupport (fields, values);
167 }
168
169 public void testCaseSensitivityPreserved() throws Exception
170 {
171 String [] names = {"Name", "DescriptorType"};
172 String [] values = {"test", "mbean"};
173 DescriptorSupport descriptor = new DescriptorSupport (names, values);
174
175 String value = (String )descriptor.getFieldValue("name");
177 assertNotNull(value);
178 assertEquals(value, values[0]);
179 value = (String )descriptor.getFieldValue("descriptorType");
180 assertNotNull(value);
181 assertEquals(value, values[1]);
182
183 String [] fieldNames = descriptor.getFieldNames();
185 assertNotNull(fieldNames);
186 assertEquals(fieldNames.length, 2);
187 if (!fieldNames[0].equals(names[0]) && !fieldNames[0].equals(names[1])) fail();
188 if (!fieldNames[1].equals(names[0]) && !fieldNames[1].equals(names[1])) fail();
189
190 ByteArrayOutputStream baos = new ByteArrayOutputStream ();
192 ObjectOutputStream oos = new ObjectOutputStream (baos);
193 oos.writeObject(descriptor);
194 oos.close();
195 ByteArrayInputStream bais = new ByteArrayInputStream (baos.toByteArray());
196 ObjectInputStream ois = new ObjectInputStream (bais);
197 DescriptorSupport newDescriptor = (DescriptorSupport )ois.readObject();
198 value = (String )newDescriptor.getFieldValue("name");
199 assertNotNull(value);
200 assertEquals(value, values[0]);
201 fieldNames = newDescriptor.getFieldNames();
203 assertNotNull(fieldNames);
204 assertEquals(fieldNames.length, 2);
205 if (!fieldNames[0].equals(names[0]) && !fieldNames[0].equals(names[1])) fail();
206 if (!fieldNames[1].equals(names[0]) && !fieldNames[1].equals(names[1])) fail();
207
208 descriptor.removeField("name");
210 value = (String )descriptor.getFieldValue("name");
211 assertNull(value);
212 fieldNames = descriptor.getFieldNames();
213 assertNotNull(fieldNames);
214 assertEquals(fieldNames.length, 1);
215 assertEquals(fieldNames[0], names[1]);
216 }
217
218 public void testDefaultFieldValuesSize() throws Exception
219 {
220 DescriptorSupport ds = new DescriptorSupport ();
221 Object [] fields = ds.getFieldValues(null);
222 assertTrue("Expecting 0 length array", fields.length == 0);
223 }
224
225 public void testNullDescriptorConstructorParam() throws Exception
226 {
227 DescriptorSupport ds = new DescriptorSupport ((DescriptorSupport )null);
228 assertNotNull(ds.getFields());
229 assertEquals("Expecting the descriptor to be empty", ds.getFields().length, 0);
230 assertFalse("Expecting the descriptor to be invalid", ds.isValid());
231 }
232
233 public void testNullStringConstructorParam() throws Exception
234 {
235 try
236 {
237 new DescriptorSupport ((String )null);
238 fail("Expecting RuntimeOperationsException");
239 }
240 catch (RuntimeOperationsException x)
241 {
242 if (!(x.getTargetException() instanceof IllegalArgumentException ))
243 fail("Target exception should be IllegalArgumentException");
244 }
245 }
246
247 public void testNullStringArrayCtorParm() throws Exception
248 {
249 String [] nullfields = null;
250 DescriptorSupport ds = new DescriptorSupport (nullfields);
251 Object [] fields = ds.getFieldValues(null);
252 assertEquals("Expecting 0 length array", fields.length, 0);
253 }
254
255 public void testToXMLString() throws Exception
256 {
257 String [] fields = {"wine", "vineyard", "year", "price"};
258 Object [] values = {"Amarone", "Allegrini", "1996", new Integer (90)};
259 DescriptorSupport ds = new DescriptorSupport (fields, values);
260 String xml = ds.toXMLString();
261 assertTrue("Descriptor from XML != Descriptor", descriptorsEqual(ds, (new DescriptorSupport (xml))));
262
263 fields = new String []{"wine=Amarone", "vineyard=Allegrini", "year=1996"};
264 ds = new DescriptorSupport (fields);
265 xml = ds.toXMLString();
266 assertTrue("Descriptor from XML != Descriptor", descriptorsEqual(ds, (new DescriptorSupport (xml))));
267 }
268
269 public void testEmptyDescriptorToXMLString() throws Exception
270 {
271 DescriptorSupport ds = new DescriptorSupport ();
272 String xml = ds.toXMLString();
273 assertEquals("Unexpected xml: " + xml, xml, "<Descriptor></Descriptor>");
274 }
275
276 public void testGetFieldsUnknownName()
277 {
278 String [] fields = {"wine", "vineyard", "year"};
279 String [] values = {"Amarone", "Allegrini", "1996"};
280 DescriptorSupport ds = new DescriptorSupport (fields, values);
281 Object fv = ds.getFieldValue("price");
282 assertNull(fv);
283 fields = new String []{"wine", "vineyard", "year", "price"};
284 Object [] fvs = ds.getFieldValues(fields);
285 assertEquals("wrong number of values", fvs.length, fields.length);
286 assertNull(fvs[3]);
287 }
288
289 public void testGetFieldsEmptyArray()
290 {
291 String [] fields = {"wine", "vineyard", "year"};
292 String [] values = {"Amarone", "Allegrini", "1996"};
293 DescriptorSupport ds = new DescriptorSupport (fields, values);
294 Object [] fvs = ds.getFieldValues(new String [0]);
295 assertEquals("Expecting empty array", fvs.length, 0);
296 }
297
298 public void testRemoveField()
299 {
300 String [] fields = {"wine", "vineyard", "year", "price"};
301 Object [] values = {"Amarone", "Allegrini", "1996", new Integer (90)};
302 DescriptorSupport ds = new DescriptorSupport (fields, values);
303 assertEquals("Expecting " + fields.length + " names", ds.getFieldNames().length, fields.length);
304 ds.removeField("price");
305 assertEquals("Expecting " + (fields.length - 1) + " names", ds.getFieldNames().length, fields.length - 1);
306 }
307
308 public void testRemoveNonexistentFieldDoesntThrow()
309 {
310 String [] fields = {"wine", "vineyard", "year"};
311 String [] values = {"Amarone", "Allegrini", "1996"};
312 DescriptorSupport ds = new DescriptorSupport (fields, values);
313 ds.removeField("price");
314 }
315
316 public void testRemoveNullField()
317 {
318 String [] fields = {"wine", "vineyard", "year"};
319 String [] values = {"Amarone", "Allegrini", "1996"};
320 DescriptorSupport ds = new DescriptorSupport (fields, values);
321 ds.removeField(null);
322 }
323
324 public void testXMLStringConstructor() throws Exception
325 {
326 StringBuffer xmldescriptor = new StringBuffer ();
327 xmldescriptor.append("<Descriptor>");
328 xmldescriptor.append("<field ");
329 xmldescriptor.append("name=\"bogus\" ");
330 xmldescriptor.append("value=\"xyzzy\"");
331 xmldescriptor.append(">");
332 xmldescriptor.append("</field>");
333 xmldescriptor.append("</Descriptor>");
334 DescriptorSupport ds = new DescriptorSupport (xmldescriptor.toString());
335 String xml = ds.toXMLString();
336 assertTrue("Descriptor from XML != Descriptor", descriptorsEqual(ds, (new DescriptorSupport (xml))));
337 }
338
339 public void testXMLSpecialStringConstructor() throws Exception
340 {
341 String [] fields = {"name=Lawrence", "nickname=(Larry)"};
342 DescriptorSupport ds = new DescriptorSupport (fields);
343 String xml = ds.toXMLString();
344 DescriptorSupport xmlds = new DescriptorSupport (xml);
345 assertTrue("Descriptors not equal", descriptorsEqual(ds, xmlds));
346 }
347
348 public void testXMLPrimitiveConstructor() throws Exception
349 {
350 StringBuffer xmldescriptor = new StringBuffer ();
351 xmldescriptor.append("<Descriptor>");
352 xmldescriptor.append("<field ");
353 xmldescriptor.append("name=\"boolean\" ");
354 xmldescriptor.append("value=\"(java.lang.Boolean/true)\"");
355 xmldescriptor.append(">");
356 xmldescriptor.append("</field>");
357 xmldescriptor.append("<field ");
358 xmldescriptor.append("name=\"byte\" ");
359 xmldescriptor.append("value=\"(java.lang.Byte/127)\"");
360 xmldescriptor.append(">");
361 xmldescriptor.append("</field>");
362 xmldescriptor.append("<field ");
363 xmldescriptor.append("name=\"char\" ");
364 xmldescriptor.append("value=\"(java.lang.Character/k)\"");
365 xmldescriptor.append(">");
366 xmldescriptor.append("</field>");
367 xmldescriptor.append("<field ");
368 xmldescriptor.append("name=\"short\" ");
369 xmldescriptor.append("value=\"(java.lang.Short/4096)\"");
370 xmldescriptor.append(">");
371 xmldescriptor.append("</field>");
372 xmldescriptor.append("<field ");
373 xmldescriptor.append("name=\"int\" ");
374 xmldescriptor.append("value=\"(java.lang.Integer/16384)\"");
375 xmldescriptor.append(">");
376 xmldescriptor.append("</field>");
377 xmldescriptor.append("<field ");
378 xmldescriptor.append("name=\"long\" ");
379 xmldescriptor.append("value=\"(java.lang.Long/123456789)\"");
380 xmldescriptor.append(">");
381 xmldescriptor.append("</field>");
382 xmldescriptor.append("<field ");
383 xmldescriptor.append("name=\"float\" ");
384 xmldescriptor.append("value=\"(java.lang.Float/3.14)\"");
385 xmldescriptor.append(">");
386 xmldescriptor.append("</field>");
387 xmldescriptor.append("<field ");
388 xmldescriptor.append("name=\"double\" ");
389 xmldescriptor.append("value=\"(java.lang.Double/3.14e-10)\"");
390 xmldescriptor.append(">");
391 xmldescriptor.append("</field>");
392 xmldescriptor.append("<field ");
393 xmldescriptor.append("name=\"null\" ");
394 xmldescriptor.append("value=\"(null)\"");
395 xmldescriptor.append(">");
396 xmldescriptor.append("</field>");
397 xmldescriptor.append("</Descriptor>");
398 DescriptorSupport ds = new DescriptorSupport (xmldescriptor.toString());
399 String xml = ds.toXMLString();
400 assertTrue("Descriptor from XML != Descriptor", descriptorsEqual(ds, (new DescriptorSupport (xml))));
401 }
402
403 public void testXMLClassConstructor() throws Exception
404 {
405 StringBuffer xmldescriptor = new StringBuffer ();
406 xmldescriptor.append("<Descriptor>");
407 xmldescriptor.append("<field ");
408 xmldescriptor.append("name=\"date\" ");
409 xmldescriptor.append("value=\"(java.net.URL/http://mx4j.sourceforge.net)\"");
410 xmldescriptor.append(">");
411 xmldescriptor.append("</field>");
412 xmldescriptor.append("</Descriptor>");
413 DescriptorSupport ds = new DescriptorSupport (xmldescriptor.toString());
414 String xml = ds.toXMLString();
415 assertTrue("Descriptor from XML != Descriptor", descriptorsEqual(ds, (new DescriptorSupport (xml))));
416 }
417
418 public void testBogusXMLConstructor() throws Exception
419 {
420 try
421 {
422 new DescriptorSupport ("<Descriptor><field name=</Descriptor>");
423 fail("Expecting XMLParseException");
424 }
425 catch (XMLParseException x)
426 {
427 }
428 }
429
430 public void testBogusXMLValueCtor() throws Exception
431 {
432 try
433 {
434 StringBuffer xmldescriptor = new StringBuffer ();
435 xmldescriptor.append("<Descriptor>");
436 xmldescriptor.append("<field ");
437 xmldescriptor.append("name=\"bogus\" ");
438 xmldescriptor.append("value=\"(java.lang.Byte/256)\"");
439 xmldescriptor.append(">");
440 xmldescriptor.append("</field>");
441 xmldescriptor.append("</Descriptor>");
442 new DescriptorSupport (xmldescriptor.toString());
443 fail("Expecting XMLParseException");
444 }
445 catch (XMLParseException x)
446 {
447 }
448 }
449
450 private boolean descriptorsEqual(Descriptor done, Descriptor dtwo)
451 {
452 Set namesone = new HashSet (Arrays.asList(done.getFieldNames()));
453 Set namestwo = new HashSet (Arrays.asList(dtwo.getFieldNames()));
454 if (!namesone.equals(namestwo)) return false;
455 Iterator i = namesone.iterator();
456 while (i.hasNext())
457 {
458 String field = (String )i.next();
459 Object vone = done.getFieldValue(field);
460 Object vtwo = dtwo.getFieldValue(field);
461 if ((vone == null && vtwo != null) || (vone != null && !vone.equals(vtwo)))
462 {
463 return false;
464 }
465 }
466 return true;
467 }
468 }
469 |
Popular Tags |
Java API By Example, From Geeks To Geeks.