|
1
8 package test.javax.management.openmbean;
9
10 import java.util.Iterator  ;
11 import java.util.Set ;
12 import javax.management.openmbean.ArrayType ;
13 import javax.management.openmbean.OpenDataException ;
14 import javax.management.openmbean.OpenMBeanParameterInfo ;
15 import javax.management.openmbean.OpenMBeanParameterInfoSupport ;
16 import javax.management.openmbean.SimpleType ;
17
18 import junit.framework.TestCase;
19 import test.javax.management.compliance.serialization.support.Serializer;
20
21
24
25 public class OpenMBeanParameterInfoSupportTest extends TestCase
26 {
27 private String [] legalModels;
28 private String [] legalColors;
29 private static String [] legalSizes;
30 private float minPrice;
31 private float maxPrice;
32 private OpenMBeanParameterInfoSupport priceParamInfo;
33
34 public OpenMBeanParameterInfoSupportTest(String s)
35 {
36 super(s);
37 }
38
39 protected void setUp() throws Exception
40 {
41 super.setUp();
42 legalModels = new String []{"JDMK", "JMX", "JAVA"};
43 legalColors = new String []{"black", "white", "red", "green", "blue"};
44 legalSizes = new String []{"S", "M", "L", "XL", "XXL"};
45 minPrice = 9.00f;
46 maxPrice = 19.99f;
47 priceParamInfo = new OpenMBeanParameterInfoSupport ("price",
48 "Valid product price",
49 SimpleType.FLOAT,
50 new Float (10.00), new Float (minPrice), new Float (maxPrice)); }
54
55 protected void tearDown() throws Exception
56 {
57 super.tearDown();
58 }
59
60 public void testEquals()
61 {
62 try
63 {
64 OpenMBeanParameterInfoSupport infoSupport = new OpenMBeanParameterInfoSupport ("test", "hello world", SimpleType.STRING, "black", legalColors);
65 OpenMBeanParameterInfoSupport equalInfoSupport = new OpenMBeanParameterInfoSupport ("test", "hello world", SimpleType.STRING, "black", legalColors);
66 OpenMBeanParameterInfoSupport info2Support = new OpenMBeanParameterInfoSupport ("test2", "hello world2", SimpleType.STRING);
67
68
69 OpenMBeanParameterInfoSupport priceParamInfo2 = new OpenMBeanParameterInfoSupport ("price",
70 "Valid product price",
71 SimpleType.FLOAT,
72 new Float (10.00), new Float (minPrice), new Float (maxPrice)); assertTrue(!(infoSupport.equals(info2Support)));
77
78 assertTrue(infoSupport.equals(equalInfoSupport));
79 assertTrue(equalInfoSupport.equals(infoSupport));
80 assertTrue(priceParamInfo.equals(priceParamInfo2));
81
82 OpenMBeanParameterInfo rebootcmd =
83 new OpenMBeanParameterInfoSupport ("reboot",
84 "Reboot the server",
85 SimpleType.INTEGER);
86 OpenMBeanParameterInfo rebootquery =
87 new OpenMBeanParameterInfoSupport ("reboot",
88 "Reboot the server",
89 SimpleType.BOOLEAN);
90 assertFalse("activeclients.equals(reboot)", rebootcmd.equals(rebootquery));
91 }
92 catch (OpenDataException e)
93 {
94 e.printStackTrace();
95 }
96
97 }
98
99 public void testDefaultSerialization()
100 {
101 int expectedHash = priceParamInfo.hashCode();
102 Serializer serializer = new Serializer();
103
104 try
105 {
106 byte[] data = serializer.serialize(priceParamInfo);
107
108 Object obj = serializer.deserialize(data);
109 assertTrue(obj instanceof OpenMBeanParameterInfo );
111
112 OpenMBeanParameterInfo type = (OpenMBeanParameterInfo )obj;
114 assertEquals(type.hashCode(), expectedHash);
116 assertTrue(type.equals(priceParamInfo));
117 assertTrue(priceParamInfo.equals(type));
118 }
119 catch (Exception e)
120 {
121 e.printStackTrace();
122 }
123 }
124
125 public void testBasicCtor()
126 {
127 OpenMBeanParameterInfoSupport info =
128 new OpenMBeanParameterInfoSupport ("currency",
129 "monetary currency",
130 SimpleType.STRING);
131 assertTrue("Null info constructed", info != null);
132 assertTrue("Unexpected name",
133 info.getName().compareTo("currency") == 0);
134 assertTrue("Unexpected description",
135 info.getDescription().compareTo("monetary currency") == 0);
136 assertTrue("Unexpected open type",
137 info.getOpenType().equals(SimpleType.STRING));
138 assertFalse("Shouldn't have default value", info.hasDefaultValue());
139 assertFalse("Shouldn't have legal values",
140 info.hasLegalValues());
141 assertFalse("Shouldn't have a min value", info.hasMinValue());
142 assertFalse("Shouldn't have a max value", info.hasMaxValue());
143 }
144
145 public void testBasicCtorNullName()
146 {
147 try
148 {
149 OpenMBeanParameterInfoSupport info =
150 new OpenMBeanParameterInfoSupport (null,
151 "monetary currency",
152 SimpleType.STRING);
153 fail("Expecting IllegalArgumentException");
154 }
155 catch (IllegalArgumentException x)
156 {
157 assertTrue(true);
158 }
159 }
160
161 public void testBasicCtorEmptyName()
162 {
163 try
164 {
165 OpenMBeanParameterInfoSupport info =
166 new OpenMBeanParameterInfoSupport ("",
167 "monetary currency",
168 SimpleType.STRING);
169 fail("Expecting IllegalArgumentException");
170 }
171 catch (IllegalArgumentException x)
172 {
173 assertTrue(true);
174 }
175 }
176
177 public void testBasicCtorNullDescription()
178 {
179 try
180 {
181 OpenMBeanParameterInfoSupport info =
182 new OpenMBeanParameterInfoSupport ("currency",
183 null,
184 SimpleType.STRING);
185 fail("Expecting IllegalArgumentException");
186 }
187 catch (IllegalArgumentException x)
188 {
189 assertTrue(true);
190 }
191 }
192
193 public void testBasicCtorEmptyDescription()
194 {
195 try
196 {
197 OpenMBeanParameterInfoSupport info =
198 new OpenMBeanParameterInfoSupport ("currency",
199 "",
200 SimpleType.STRING);
201 fail("Expecting IllegalArgumentException");
202 }
203 catch (IllegalArgumentException x)
204 {
205 assertTrue(true);
206 }
207 }
208
209 public void testBasicCtorNullOpenType()
210 {
211 try
212 {
213 OpenMBeanParameterInfoSupport info =
214 new OpenMBeanParameterInfoSupport ("currency",
215 "monetary currency",
216 null);
217 fail("Expecting IllegalArgumentException");
218 }
219 catch (IllegalArgumentException x)
220 {
221 assertTrue(true);
222 }
223 }
224
225 public void testDefaultValueCtor() throws Exception
226 {
227 OpenMBeanParameterInfoSupport info =
228 new OpenMBeanParameterInfoSupport ("currency",
229 "monetary currency",
230 SimpleType.STRING,
231 "Euro");
232 assertTrue("Null info constructed", info != null);
233 assertTrue("Unexpected name",
234 info.getName().compareTo("currency") == 0);
235 assertTrue("Unexpected description",
236 info.getDescription().compareTo("monetary currency") == 0);
237 assertTrue("Unexpected open type",
238 info.getOpenType().equals(SimpleType.STRING));
239 assertTrue("Should have default value", info.hasDefaultValue());
240 assertTrue("Unexpected default value",
241 ((String )info.getDefaultValue()).compareTo("Euro") == 0);
242 assertFalse("Shouldn't have legal values",
243 info.hasLegalValues());
244 assertFalse("Shouldn't have a min value", info.hasMinValue());
245 assertFalse("Shouldn't have a max value", info.hasMaxValue());
246 }
247
248 public void testDefaultValueCtorInvalidType() throws Exception
249 {
250 try
251 {
252 OpenMBeanParameterInfoSupport info =
253 new OpenMBeanParameterInfoSupport ("currency",
254 "monetary currency",
255 SimpleType.STRING,
256 new Float (0.42));
257 fail("Expecting OpenDataException");
258 }
259 catch (OpenDataException x)
260 {
261 assertTrue(true);
262 }
263 }
264
265 public void testDefaultValueCtorArrayType() throws Exception
266 {
267 try
268 {
269 OpenMBeanParameterInfoSupport info =
270 new OpenMBeanParameterInfoSupport ("currency",
271 "monetary currency",
272 new ArrayType (1, SimpleType.STRING),
273 null);
274 assertTrue("Null info constructed", info != null);
275
276 info =
277 new OpenMBeanParameterInfoSupport ("currency",
278 "monetary currency",
279 new ArrayType (1, SimpleType.STRING),
280 "Euro");
281 fail("Expecting OpenDataException");
282 }
283 catch (OpenDataException x)
284 {
285 assertTrue(true);
286 }
287 }
288
289 public void testLegalValueCtor() throws Exception
290 {
291 OpenMBeanParameterInfoSupport info =
292 new OpenMBeanParameterInfoSupport ("currency",
293 "monetary currency",
294 SimpleType.STRING,
295 "Euro",
296 new String []{"Dollar", "Euro", "Yen"});
297 assertTrue("Null info constructed", info != null);
298 assertTrue("Unexpected name",
299 info.getName().compareTo("currency") == 0);
300 assertTrue("Unexpected description",
301 info.getDescription().compareTo("monetary currency") == 0);
302 assertTrue("Unexpected open type",
303 info.getOpenType().equals(SimpleType.STRING));
304 assertTrue("Should have default value", info.hasDefaultValue());
305 assertTrue("Unexpected default value",
306 ((String )info.getDefaultValue()).compareTo("Euro") == 0);
307 assertTrue("Should have legal values",
308 info.getLegalValues() != null && info.getLegalValues().size() == 3);
309 assertFalse("Shouldn't have a min value", info.hasMinValue());
310 assertFalse("Shouldn't have a max value", info.hasMaxValue());
311 }
312
313 public void testLegalValueCtorInvalidType() throws Exception
314 {
315 try
316 {
317 OpenMBeanParameterInfoSupport info =
318 new OpenMBeanParameterInfoSupport ("currency",
319 "monetary currency",
320 SimpleType.STRING,
321 "Euro",
322 new Object []{"Dollar", "Euro", new Float (0.88)});
323 fail("Expecting OpenDataException");
324 }
325 catch (OpenDataException x)
326 {
327 assertTrue(true);
328 }
329 }
330
331 public void testLegalValueCtorArrayType() throws Exception
332 {
333 try
334 {
335 OpenMBeanParameterInfoSupport info =
336 new OpenMBeanParameterInfoSupport ("currency",
337 "monetary currency",
338 new ArrayType (1, SimpleType.STRING),
339 null,
340 new String []{"Dollar", "Euro", "Yen"});
341 fail("Expecting OpenDataException");
342 }
343 catch (OpenDataException x)
344 {
345 assertTrue(true);
346 }
347 }
348
349 public void testLegalValueCtorBogusDefaultValue() throws Exception
350 {
351 try
352 {
353 OpenMBeanParameterInfoSupport info =
354 new OpenMBeanParameterInfoSupport ("currency",
355 "monetary currency",
356 SimpleType.STRING,
357 "Pound",
358 new String []{"Dollar", "Euro", "Yen"});
359 fail("Expecting OpenDataException");
360 }
361 catch (OpenDataException x)
362 {
363 assertTrue(true);
364 }
365 }
366
367 public void testMinMaxValueCtor() throws Exception
368 {
369 OpenMBeanParameterInfoSupport info =
370 new OpenMBeanParameterInfoSupport ("price",
371 "how much it costs",
372 SimpleType.FLOAT,
373 new Float (1.00),
374 new Float (0.75),
375 new Float (1.50));
376 assertTrue("Null info constructed", info != null);
377 assertTrue("Unexpected name",
378 info.getName().compareTo("price") == 0);
379 assertTrue("Unexpected description",
380 info.getDescription().compareTo("how much it costs") == 0);
381 assertTrue("Unexpected open type",
382 info.getOpenType().equals(SimpleType.FLOAT));
383 assertTrue("Should have default value", info.hasDefaultValue());
384 assertTrue("Unexpected default value",
385 ((Float )info.getDefaultValue()).equals(new Float (1.00)));
386 assertFalse("Shouldn't have legal values",
387 info.hasLegalValues());
388 assertTrue("Should have a min value of 0.75",
389 info.hasMinValue()
390 && ((Float )info.getMinValue()).equals(new Float (0.75)));
391 assertTrue("Should have a max value of 1.50",
392 info.hasMaxValue()
393 && ((Float )info.getMaxValue()).equals(new Float (1.50)));
394 }
395
396 public void testMinMaxValueCtorInvalidMinType() throws Exception
397 {
398 try
399 {
400 OpenMBeanParameterInfoSupport info =
401 new OpenMBeanParameterInfoSupport ("price",
402 "how much it costs",
403 SimpleType.FLOAT,
404 new Float (1.00),
405 "0.75",
406 new Float (1.50));
407 fail("Expecting OpenDataException");
408 }
409 catch (OpenDataException x)
410 {
411 assertTrue(true);
412 }
413 }
414
415 public void testMinMaxValueCtorInvalidMaxType() throws Exception
416 {
417 try
418 {
419 OpenMBeanParameterInfoSupport info =
420 new OpenMBeanParameterInfoSupport ("price",
421 "how much it costs",
422 SimpleType.FLOAT,
423 new Float (1.00),
424 new Float (0.75),
425 "1.50");
426 fail("Expecting OpenDataException");
427 }
428 catch (OpenDataException x)
429 {
430 assertTrue(true);
431 }
432 }
433
434 public void testMinMaxValueCtorMinGTMax() throws Exception
435 {
436 try
437 {
438 OpenMBeanParameterInfoSupport info =
439 new OpenMBeanParameterInfoSupport ("price",
440 "how much it costs",
441 SimpleType.FLOAT,
442 new Float (1.00),
443 new Float (1.50),
444 new Float (0.75));
445 fail("Expecting OpenDataException");
446 }
447 catch (OpenDataException x)
448 {
449 assertTrue(true);
450 }
451 }
452
453 public void testMinMaxValueCtorDefaultOutOfRange() throws Exception
454 {
455 try
456 {
457 OpenMBeanParameterInfoSupport info =
458 new OpenMBeanParameterInfoSupport ("price",
459 "how much it costs",
460 SimpleType.FLOAT,
461 new Float (0.75),
462 new Float (1.00),
463 new Float (1.50));
464 fail("Expecting OpenDataException default < min");
465 }
466 catch (OpenDataException x)
467 {
468 assertTrue(true);
469 }
470
471 try
472 {
473 OpenMBeanParameterInfoSupport info =
474 new OpenMBeanParameterInfoSupport ("price",
475 "how much it costs",
476 SimpleType.FLOAT,
477 new Float (1.50),
478 new Float (0.75),
479 new Float (1.00));
480 fail("Expecting OpenDataException default > max");
481 }
482 catch (OpenDataException x)
483 {
484 assertTrue(true);
485 }
486 }
487
488 public void testBasicHashCode() throws Exception
489 {
490 OpenMBeanParameterInfoSupport infoone =
491 new OpenMBeanParameterInfoSupport ("currency",
492 "monetary currency",
493 SimpleType.STRING);
494 assertTrue("Unexpected basic hash code",
495 infoone.hashCode() == hashCode(infoone));
496
497 OpenMBeanParameterInfoSupport infotwo =
498 new OpenMBeanParameterInfoSupport ("currency",
499 "legal tender",
500 SimpleType.STRING);
501 assertTrue("Expecting hash codes to be equal", infotwo.hashCode() == infoone.hashCode());
502 }
503
504 public void testDefaultValueHashCode() throws Exception
505 {
506 OpenMBeanParameterInfoSupport infoone =
507 new OpenMBeanParameterInfoSupport ("currency",
508 "monetary currency",
509 SimpleType.STRING,
510 "Euro");
511 assertTrue("Unexpected default value hash code",
512 infoone.hashCode() == hashCode(infoone));
513
514 OpenMBeanParameterInfoSupport infotwo =
515 new OpenMBeanParameterInfoSupport ("currency",
516 "legal tender",
517 SimpleType.STRING,
518 "Euro");
519 assertTrue("Unexpected default value hash code",
520 infotwo.hashCode() == infoone.hashCode());
521 }
522
523 public void testLegalValueHashCode() throws Exception
524 {
525 OpenMBeanParameterInfoSupport infoone =
526 new OpenMBeanParameterInfoSupport ("currency",
527 "monetary currency",
528 SimpleType.STRING,
529 "Euro",
530 new String []{"Dollar", "Euro", "Yen"});
531 assertTrue("Unexpected legal value hash code",
532 infoone.hashCode() == hashCode(infoone));
533
534 OpenMBeanParameterInfoSupport infotwo =
535 new OpenMBeanParameterInfoSupport ("currency",
536 "monetary currency",
537 SimpleType.STRING,
538 "Euro",
539 new String []{"Dollar", "Euro", "Yen"});
540 assertTrue("Unexpected legal value hash code",
541 infoone.hashCode() == hashCode(infotwo));
542 }
543
544 public void testMinMaxHashCode() throws Exception
545 {
546 OpenMBeanParameterInfoSupport infoone =
547 new OpenMBeanParameterInfoSupport ("price",
548 "how much it costs",
549 SimpleType.FLOAT,
550 new Float (1.00),
551 new Float (0.75),
552 new Float (1.50));
553 assertTrue("Unexpected minmax hash code",
554 infoone.hashCode() == hashCode(infoone));
555
556 OpenMBeanParameterInfoSupport infotwo =
557 new OpenMBeanParameterInfoSupport ("price",
558 "retail",
559 SimpleType.FLOAT,
560 new Float (1.00),
561 new Float (0.75),
562 new Float (1.50));
563 assertTrue("Unexpected minmax hash code",
564 infotwo.hashCode() == infoone.hashCode());
565 }
566
567 private int hashCode(OpenMBeanParameterInfo info)
568 {
569 int result = info.getName().hashCode();
570 result += info.getOpenType().hashCode();
571 result += (info.hasDefaultValue() == false) ? 0 : info.getDefaultValue().hashCode();
572 result += (info.hasLegalValues() == false) ? 0 : hashCode(info.getLegalValues());
573 result += (info.hasMinValue() == false) ? 0 : info.getMinValue().hashCode();
574 result += (info.hasMaxValue() == false) ? 0 : info.getMaxValue().hashCode();
575 return result;
576 }
577
578 private int hashCode(Set legalvalues)
579 {
580 int result = 0;
581 Iterator i = legalvalues.iterator();
582 while (i.hasNext())
583 {
584 Object v = i.next();
585 result += v.hashCode();
586 }
587 return result;
588 }
589 }
590 |
Popular Tags |
Java API By Example, From Geeks To Geeks.