|
1
22 package org.jboss.test.jmx.compliance.openmbean;
23
24 import junit.framework.TestCase;
25
26 import java.io.ByteArrayInputStream  ;
27 import java.io.ByteArrayOutputStream ;
28 import java.io.ObjectInputStream ;
29 import java.io.ObjectOutputStream ;
30 import java.util.Set ;
31
32 import javax.management.openmbean.CompositeData ;
33 import javax.management.openmbean.CompositeDataSupport ;
34 import javax.management.openmbean.CompositeType ;
35 import javax.management.openmbean.OpenDataException ;
36 import javax.management.openmbean.OpenType ;
37 import javax.management.openmbean.SimpleType ;
38
39
44 public class CompositeTypeTestCase
45 extends TestCase
46 {
47
49
51
53
56 public CompositeTypeTestCase(String s)
57 {
58 super(s);
59 }
60
61
63 public void testCompositeTypeOpenType()
64 throws Exception
65 {
66 String [] itemNames = new String [] { "name1", "name2" };
67 String [] itemDescriptions = new String [] { "desc1", "desc2" };
68 OpenType [] itemTypes = new OpenType [] { SimpleType.STRING, SimpleType.INTEGER };
69 CompositeType compositeType = new CompositeType ("typeName", "description",
70 itemNames, itemDescriptions, itemTypes);
71 assertEquals(CompositeData .class.getName(), compositeType.getClassName());
72 assertEquals("description", compositeType.getDescription());
73 assertEquals("typeName", compositeType.getTypeName());
74 assertTrue("Composite type should not be an array", compositeType.isArray() == false);
75 }
76
77 public void testContainsKey()
78 throws Exception
79 {
80 String [] itemNames = new String [] { "name1", "name2" };
81 String [] itemDescriptions = new String [] { "desc1", "desc2" };
82 OpenType [] itemTypes = new OpenType [] { SimpleType.STRING, SimpleType.INTEGER };
83 CompositeType compositeType = new CompositeType ("typeName", "description",
84 itemNames, itemDescriptions, itemTypes);
85 assertTrue("Composite type should contain key name1", compositeType.containsKey("name1") == true);
86 assertTrue("Composite type should contain key name2", compositeType.containsKey("name2") == true);
87 assertTrue("Composite type should not contain key nameX", compositeType.containsKey("nameX") == false);
88 assertTrue("Composite type should not contain key null", compositeType.containsKey(null) == false);
89 assertTrue("Composite type should not contain key <empty>", compositeType.containsKey("") == false);
90 }
91
92 public void testGetDescriptionForItemName()
93 throws Exception
94 {
95 String [] itemNames = new String [] { "name1", "name2" };
96 String [] itemDescriptions = new String [] { "desc1", "desc2" };
97 OpenType [] itemTypes = new OpenType [] { SimpleType.STRING, SimpleType.INTEGER };
98 CompositeType compositeType = new CompositeType ("typeName", "description",
99 itemNames, itemDescriptions, itemTypes);
100 assertEquals("desc1", compositeType.getDescription("name1"));
101 assertEquals("desc2", compositeType.getDescription("name2"));
102 }
103
104 public void testGetTypeForItemName()
105 throws Exception
106 {
107 String [] itemNames = new String [] { "name1", "name2" };
108 String [] itemDescriptions = new String [] { "desc1", "desc2" };
109 OpenType [] itemTypes = new OpenType [] { SimpleType.STRING, SimpleType.INTEGER };
110 CompositeType compositeType = new CompositeType ("typeName", "description",
111 itemNames, itemDescriptions, itemTypes);
112 assertEquals(SimpleType.STRING, compositeType.getType("name1"));
113 assertEquals(SimpleType.INTEGER, compositeType.getType("name2"));
114 }
115
116 public void testKeySet()
117 throws Exception
118 {
119 String [] itemNames = new String [] { "name1", "name2" };
120 String [] itemDescriptions = new String [] { "desc1", "desc2" };
121 OpenType [] itemTypes = new OpenType [] { SimpleType.STRING, SimpleType.INTEGER };
122 CompositeType compositeType = new CompositeType ("typeName", "description",
123 itemNames, itemDescriptions, itemTypes);
124 Set keys = compositeType.keySet();
125 assertTrue("Should be 2 items", keys.size() == 2);
126 assertTrue("Should contain name1", keys.contains("name1"));
127 assertTrue("Should contain name2", keys.contains("name2"));
128 }
129
130 public void testIsValue()
131 throws Exception
132 {
133 String [] itemNames = new String [] { "name1", "name2" };
134 String [] itemDescriptions = new String [] { "desc1", "desc2" };
135 OpenType [] itemTypes = new OpenType [] { SimpleType.STRING, SimpleType.INTEGER };
136 CompositeType compositeType = new CompositeType ("typeName", "description",
137 itemNames, itemDescriptions, itemTypes);
138
139 assertTrue("null is not a value of composite type", compositeType.isValue(null) == false);
140 assertTrue("object is not a value of composite type", compositeType.isValue(new Object ()) == false);
141
142 Object [] itemValues = new Object [] { "string", new Integer (2) };
143 CompositeDataSupport data = new CompositeDataSupport (compositeType, itemNames, itemValues);
144 assertTrue("data should be a value of composite type", compositeType.isValue(data));
145
146 CompositeType compositeType2 = new CompositeType ("typeName", "description",
147 itemNames, itemDescriptions, itemTypes);
148 data = new CompositeDataSupport (compositeType2, itemNames, itemValues);
149 assertTrue("data should be a value of composite type, even though not the object instance",
150 compositeType.isValue(data));
151
152 OpenType [] itemTypes2 = new OpenType [] { SimpleType.STRING, SimpleType.LONG };
153 compositeType2 = new CompositeType ("typeName", "description",
154 itemNames, itemDescriptions, itemTypes2);
155 Object [] itemValues2 = new Object [] { "string", new Long (2) };
156 data = new CompositeDataSupport (compositeType2, itemNames, itemValues2);
157 assertTrue("data should not be a value of composite type, it has different types",
158 compositeType.isValue(data) == false);
159
160 compositeType2 = new CompositeType ("typeName2", "description",
161 itemNames, itemDescriptions, itemTypes);
162 data = new CompositeDataSupport (compositeType2, itemNames, itemValues);
163 assertTrue("data should not be a value of composite type, it has a different type name",
164 compositeType.isValue(data) == false);
165
166 String [] itemNames2 = new String [] { "nameX", "name2" };
167 compositeType2 = new CompositeType ("typeName", "description",
168 itemNames2, itemDescriptions, itemTypes);
169 data = new CompositeDataSupport (compositeType2, itemNames2, itemValues);
170 assertTrue("data should not be a value of composite type, it has different item names",
171 compositeType.isValue(data) == false);
172 }
173
174 public void testEquals()
175 throws Exception
176 {
177 String [] itemNames = new String [] { "name1", "name2" };
178 String [] itemDescriptions = new String [] { "desc1", "desc2" };
179 OpenType [] itemTypes = new OpenType [] { SimpleType.STRING, SimpleType.INTEGER };
180 CompositeType compositeType = new CompositeType ("typeName", "description",
181 itemNames, itemDescriptions, itemTypes);
182
183 assertTrue("null is not equal composite type", compositeType.equals(null) == false);
184 assertTrue("object is not equal composite type", compositeType.equals(new Object ()) == false);
185
186 CompositeType compositeType2 = new CompositeType ("typeName", "description",
187 itemNames, itemDescriptions, itemTypes);
188 assertTrue("compositeType2 should be equal composite type, even though not the object instance",
189 compositeType.equals(compositeType2));
190 assertTrue("compositeType2 should be equal composite type, even though not the object instance",
191 compositeType2.equals(compositeType));
192
193 OpenType [] itemTypes2 = new OpenType [] { SimpleType.STRING, SimpleType.LONG };
194 compositeType2 = new CompositeType ("typeName", "description",
195 itemNames, itemDescriptions, itemTypes2);
196 assertTrue("compositeType2 should not be equal composite type, it has different types",
197 compositeType.equals(compositeType2) == false);
198 assertTrue("compositeType2 should not be equal composite type, it has different types",
199 compositeType2.equals(compositeType) == false);
200
201 compositeType2 = new CompositeType ("typeName2", "description",
202 itemNames, itemDescriptions, itemTypes);
203 assertTrue("compositeType2 should not be equal composite type, it has a different type name",
204 compositeType.equals(compositeType2) == false);
205 assertTrue("compositeType2 should not be equal composite type, it has a different type name",
206 compositeType2.equals(compositeType) == false);
207
208 String [] itemNames2 = new String [] { "nameX", "name2" };
209 compositeType2 = new CompositeType ("typeName", "description",
210 itemNames2, itemDescriptions, itemTypes);
211 assertTrue("compositeType2 should not be equal composite type, it has different item names",
212 compositeType.equals(compositeType2) == false);
213 assertTrue("compositeType2 should not be equal composite type, it has different item names",
214 compositeType2.equals(compositeType) == false);
215 }
216
217 public void testHashCode()
218 throws Exception
219 {
220 String [] itemNames = new String [] { "name1", "name2" };
221 String [] itemDescriptions = new String [] { "desc1", "desc2" };
222 OpenType [] itemTypes = new OpenType [] { SimpleType.STRING, SimpleType.INTEGER };
223 CompositeType compositeType = new CompositeType ("typeName", "description",
224 itemNames, itemDescriptions, itemTypes);
225
226 int myHashCode = "typeName".hashCode() + SimpleType.STRING.hashCode() + SimpleType.INTEGER.hashCode()
227 + "name1".hashCode() + "name2".hashCode();
228 assertTrue("Wrong hash code generated", myHashCode == compositeType.hashCode());
229 }
230
231 public void testToString()
232 throws Exception
233 {
234 String [] itemNames = new String [] { "name1", "name2" };
235 String [] itemDescriptions = new String [] { "desc1", "desc2" };
236 OpenType [] itemTypes = new OpenType [] { SimpleType.STRING, SimpleType.INTEGER };
237 CompositeType compositeType = new CompositeType ("typeName", "description",
238 itemNames, itemDescriptions, itemTypes);
239
240 String toString = compositeType.toString();
241
242 assertTrue("toString() should contain the composite type class name",
243 toString.indexOf(CompositeType .class.getName()) != -1);
244 assertTrue("toString() should contain the item name name1",
245 toString.indexOf("name1") != -1);
246 assertTrue("toString() should contain the item name name2",
247 toString.indexOf("name2") != -1);
248 assertTrue("toString() should contain " + SimpleType.STRING,
249 toString.indexOf(SimpleType.STRING.toString()) != -1);
250 assertTrue("toString() should contain " + SimpleType.INTEGER,
251 toString.indexOf(SimpleType.INTEGER.toString()) != -1);
252 }
253
254 public void testSerialization()
255 throws Exception
256 {
257 String [] itemNames = new String [] { "name1", "name2" };
258 String [] itemDescriptions = new String [] { "desc1", "desc2" };
259 OpenType [] itemTypes = new OpenType [] { SimpleType.STRING, SimpleType.INTEGER };
260 CompositeType compositeType = new CompositeType ("typeName", "description",
261 itemNames, itemDescriptions, itemTypes);
262
263 ByteArrayOutputStream baos = new ByteArrayOutputStream ();
265 ObjectOutputStream oos = new ObjectOutputStream (baos);
266 oos.writeObject(compositeType);
267
268 ByteArrayInputStream bais = new ByteArrayInputStream (baos.toByteArray());
270 ObjectInputStream ois = new ObjectInputStream (bais);
271 Object result = ois.readObject();
272
273 assertEquals(compositeType, result);
274 }
275
276 public void testErrors()
277 throws Exception
278 {
279 String [] itemNames = new String [] { "name1", "name2" };
280 String [] itemDescriptions = new String [] { "desc1", "desc2" };
281 OpenType [] itemTypes = new OpenType [] { SimpleType.STRING, SimpleType.INTEGER };
282
283 boolean caught = false;
284 try
285 {
286 new CompositeType (null, "description", itemNames, itemDescriptions, itemTypes);
287 }
288 catch (IllegalArgumentException e)
289 {
290 caught = true;
291 }
292 if (caught == false)
293 fail("Excepted IllegalArgumentException for null typeName");
294
295 caught = false;
296 try
297 {
298 new CompositeType ("", "description", itemNames, itemDescriptions, itemTypes);
299 }
300 catch (IllegalArgumentException e)
301 {
302 caught = true;
303 }
304 if (caught == false)
305 fail("Excepted IllegalArgumentException for empty typeName");
306
307 caught = false;
308 try
309 {
310 new CompositeType ("typeName", null, itemNames, itemDescriptions, itemTypes);
311 }
312 catch (IllegalArgumentException e)
313 {
314 caught = true;
315 }
316 if (caught == false)
317 fail("Excepted IllegalArgumentException for null description");
318
319 caught = false;
320 try
321 {
322 new CompositeType ("typeName", "", itemNames, itemDescriptions, itemTypes);
323 }
324 catch (IllegalArgumentException e)
325 {
326 caught = true;
327 }
328 if (caught == false)
329 fail("Excepted IllegalArgumentException for empty description");
330
331 caught = false;
332 try
333 {
334 new CompositeType ("typeName", "description", null, itemDescriptions, itemTypes);
335 }
336 catch (IllegalArgumentException e)
337 {
338 caught = true;
339 }
340 if (caught == false)
341 fail("Excepted IllegalArgumentException for null item names");
342
343 caught = false;
344 try
345 {
346 new CompositeType ("typeName", "description", itemNames, null, itemTypes);
347 }
348 catch (IllegalArgumentException e)
349 {
350 caught = true;
351 }
352 if (caught == false)
353 fail("Excepted IllegalArgumentException for null item descriptions");
354
355 caught = false;
356 try
357 {
358 new CompositeType ("typeName", "description", itemNames, itemDescriptions, null);
359 }
360 catch (IllegalArgumentException e)
361 {
362 caught = true;
363 }
364 if (caught == false)
365 fail("Excepted IllegalArgumentException for null item types");
366
367 String [] nullItemNames = new String [] { "name1", null };
368 caught = false;
369 try
370 {
371 new CompositeType ("typeName", "description", nullItemNames, itemDescriptions, itemTypes);
372 }
373 catch (IllegalArgumentException e)
374 {
375 caught = true;
376 }
377 if (caught == false)
378 fail("Excepted IllegalArgumentException for null element of item names");
379
380 String [] nullItemDescriptions = new String [] { "desc1", null };
381 caught = false;
382 try
383 {
384 new CompositeType ("typeName", "description", itemNames, nullItemDescriptions, itemTypes);
385 }
386 catch (IllegalArgumentException e)
387 {
388 caught = true;
389 }
390 if (caught == false)
391 fail("Excepted IllegalArgumentException for null element of item descriptions");
392
393 OpenType [] nullItemTypes = new OpenType [] { SimpleType.STRING, null };
394 caught = false;
395 try
396 {
397 new CompositeType ("typeName", "description", itemNames, itemDescriptions, nullItemTypes);
398 }
399 catch (IllegalArgumentException e)
400 {
401 caught = true;
402 }
403 if (caught == false)
404 fail("Excepted IllegalArgumentException for null element of item types");
405
406 String [] wrongItemNames = new String [] { "name1" };
407 caught = false;
408 try
409 {
410 new CompositeType ("typeName", "description", wrongItemNames, itemDescriptions, itemTypes);
411 }
412 catch (IllegalArgumentException e)
413 {
414 caught = true;
415 }
416 if (caught == false)
417 fail("Excepted IllegalArgumentException for wrong number of elements for item names");
418
419 String [] wrongItemDescriptions = new String [] { "desc1"};
420 caught = false;
421 try
422 {
423 new CompositeType ("typeName", "description", itemNames, wrongItemDescriptions, itemTypes);
424 }
425 catch (IllegalArgumentException e)
426 {
427 caught = true;
428 }
429 if (caught == false)
430 fail("Excepted IllegalArgumentException for wrong number of elements for item descriptions");
431
432 OpenType [] wrongItemTypes = new OpenType [] { SimpleType.STRING };
433 caught = false;
434 try
435 {
436 new CompositeType ("typeName", "description", itemNames, itemDescriptions, wrongItemTypes);
437 }
438 catch (IllegalArgumentException e)
439 {
440 caught = true;
441 }
442 if (caught == false)
443 fail("Excepted IllegalArgumentException for wrong number of elements for item types");
444
445 String [] duplicateItemNames = new String [] { "desc1", "desc1" };
446 caught = false;
447 try
448 {
449 new CompositeType ("typeName", "description", duplicateItemNames, itemDescriptions, itemTypes);
450 }
451 catch (OpenDataException e)
452 {
453 caught = true;
454 }
455 if (caught == false)
456 fail("Excepted OpenDataException for duplicate item names");
457
458 duplicateItemNames = new String [] { "desc1", " desc1 " };
459 caught = false;
460 try
461 {
462 new CompositeType ("typeName", "description", duplicateItemNames, itemDescriptions, itemTypes);
463 }
464 catch (OpenDataException e)
465 {
466 caught = true;
467 }
468 if (caught == false)
469 fail("Excepted OpenDataException for duplicate item names");
470 }
471
472 }
474 |
Popular Tags |
Java API By Example, From Geeks To Geeks.