|
1
7
8 package test.compliance.openmbean;
9
10 import java.io.ByteArrayInputStream;
11 import java.io.ByteArrayOutputStream;
12 import java.io.ObjectInputStream;
13 import java.io.ObjectOutputStream;
14 import java.util.Arrays;
15 import java.util.Collection;
16 import java.util.HashMap;
17 import java.util.Map;
18 import java.util.Set;
19
20 import javax.management.openmbean.CompositeData;
21 import javax.management.openmbean.CompositeDataSupport;
22 import javax.management.openmbean.CompositeType;
23 import javax.management.openmbean.InvalidKeyException;
24 import javax.management.openmbean.InvalidOpenTypeException;
25 import javax.management.openmbean.KeyAlreadyExistsException;
26 import javax.management.openmbean.OpenType;
27 import javax.management.openmbean.SimpleType;
28 import javax.management.openmbean.TabularDataSupport;
29 import javax.management.openmbean.TabularType;
30
31 import junit.framework.TestCase;
32
33
38 public class TabularDataSupportTestCase
39 extends TestCase
40 {
41
43
45
47
50 public TabularDataSupportTestCase(String s)
51 {
52 super(s);
53 }
54
55
57 public void testTabularDataSupport()
58 throws Exception
59 {
60 String[] itemNames = new String[] { "name1", "name2" };
61 String[] itemDescriptions = new String[] { "desc1", "desc2" };
62 OpenType[] itemTypes = new OpenType[] { SimpleType.STRING, SimpleType.INTEGER };
63 CompositeType rowType = new CompositeType("rowTypeName", "rowDescription",
64 itemNames, itemDescriptions, itemTypes);
65
66 String[] indexNames = new String[] { "name1", "name2" };
67 TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);
68
69 TabularDataSupport data = new TabularDataSupport(tabularType);
70 TabularDataSupport data2 = new TabularDataSupport(tabularType, 100, .5f);
71 }
72
73 public void testGetTabularType()
74 throws Exception
75 {
76 String[] itemNames = new String[] { "name1", "name2" };
77 String[] itemDescriptions = new String[] { "desc1", "desc2" };
78 OpenType[] itemTypes = new OpenType[] { SimpleType.STRING, SimpleType.INTEGER };
79 CompositeType rowType = new CompositeType("rowTypeName", "rowDescription",
80 itemNames, itemDescriptions, itemTypes);
81
82 String[] indexNames = new String[] { "name1", "name2" };
83 TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);
84
85 TabularDataSupport data = new TabularDataSupport(tabularType);
86 assertTrue("Expected the same tabular type", data.getTabularType().equals(tabularType));
87 }
88
89 public void testCalculateIndex()
90 throws Exception
91 {
92 String[] itemNames = new String[] { "name1", "name2" };
93 String[] itemDescriptions = new String[] { "desc1", "desc2" };
94 OpenType[] itemTypes = new OpenType[] { SimpleType.STRING, SimpleType.INTEGER };
95 CompositeType rowType = new CompositeType("rowTypeName", "rowDescription",
96 itemNames, itemDescriptions, itemTypes);
97
98 String[] indexNames = new String[] { "name1", "name2" };
99 TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);
100
101 TabularDataSupport data = new TabularDataSupport(tabularType);
102
103 HashMap map = new HashMap();
104 map.put("name1", "value1");
105 map.put("name2", new Integer(2));
106 CompositeDataSupport compData = new CompositeDataSupport(rowType, map);
107 Object[] index = data.calculateIndex(compData);
108
109 assertTrue("Expected index element 0 to be value1", index[0].equals("value1"));
110 assertTrue("Expected index element 1 to be 2", index[1].equals(new Integer(2)));
111
112 map = new HashMap();
113 map.put("name1", "value2");
114 map.put("name2", new Integer(3));
115 compData = new CompositeDataSupport(rowType, map);
116 index = data.calculateIndex(compData);
117
118 assertTrue("Expected index element 0 to be value2", index[0].equals("value2"));
119 assertTrue("Expected index element 1 to be 3", index[1].equals(new Integer(3)));
120 }
121
122 public void testContainsKeyObject()
123 throws Exception
124 {
125 String[] itemNames = new String[] { "name1", "name2" };
126 String[] itemDescriptions = new String[] { "desc1", "desc2" };
127 OpenType[] itemTypes = new OpenType[] { SimpleType.STRING, SimpleType.INTEGER };
128 CompositeType rowType = new CompositeType("rowTypeName", "rowDescription",
129 itemNames, itemDescriptions, itemTypes);
130
131 String[] indexNames = new String[] { "name1", "name2" };
132 TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);
133
134 TabularDataSupport data = new TabularDataSupport(tabularType);
135
136 assertTrue("Didn't expect containsKey null", data.containsKey(null) == false);
137 assertTrue("Didn't expect containsKey not an Object array", data.containsKey(new Object()) == false);
138
139 Object[] index = new Object[] { "value1", new Integer(2) };
140 assertTrue("Didn't expect containsKey on empty data", data.containsKey((Object) index) == false);
141
142 HashMap map = new HashMap();
143 map.put("name1", "value1");
144 map.put("name2", new Integer(3));
145 CompositeDataSupport compData = new CompositeDataSupport(rowType, map);
146 assertTrue("Didn't expect containsKey on index not present", data.containsKey((Object) index) == false);
147
148 map = new HashMap();
149 map.put("name1", "value1");
150 map.put("name2", new Integer(2));
151 compData = new CompositeDataSupport(rowType, map);
152 data.put(compData);
153 assertTrue("Expected containsKey", data.containsKey((Object) index));
154
155 map = new HashMap();
156 map.put("name1", "value1");
157 map.put("name2", new Integer(3));
158 compData = new CompositeDataSupport(rowType, map);
159 assertTrue("Didn't expect containsKey on index still not present",
160 data.containsKey((Object) data.calculateIndex(compData)) == false);
161
162 data.remove(index);
163 assertTrue("Didn't expect removed data in containsKey", data.containsKey((Object) index) == false);
164 }
165
166 public void testContainsKeyObjectArray()
167 throws Exception
168 {
169 String[] itemNames = new String[] { "name1", "name2" };
170 String[] itemDescriptions = new String[] { "desc1", "desc2" };
171 OpenType[] itemTypes = new OpenType[] { SimpleType.STRING, SimpleType.INTEGER };
172 CompositeType rowType = new CompositeType("rowTypeName", "rowDescription",
173 itemNames, itemDescriptions, itemTypes);
174
175 String[] indexNames = new String[] { "name1", "name2" };
176 TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);
177
178 TabularDataSupport data = new TabularDataSupport(tabularType);
179
180 assertTrue("Didn't expect containsKey null", data.containsKey(null) == false);
181 assertTrue("Didn't expect containsKey not an Object array", data.containsKey(new Object()) == false);
182
183 Object[] index = new Object[] { "value1", new Integer(2) };
184 assertTrue("Didn't expect containsKey on empty data", data.containsKey(index) == false);
185
186 HashMap map = new HashMap();
187 map.put("name1", "value1");
188 map.put("name2", new Integer(3));
189 CompositeDataSupport compData = new CompositeDataSupport(rowType, map);
190 assertTrue("Didn't expect containsKey on index not present", data.containsKey(index) == false);
191
192 map = new HashMap();
193 map.put("name1", "value1");
194 map.put("name2", new Integer(2));
195 compData = new CompositeDataSupport(rowType, map);
196 data.put(compData);
197 assertTrue("Expected containsKey", data.containsKey(index));
198
199 map = new HashMap();
200 map.put("name1", "value1");
201 map.put("name2", new Integer(3));
202 compData = new CompositeDataSupport(rowType, map);
203 assertTrue("Didn't expect containsKey on index still not present",
204 data.containsKey(data.calculateIndex(compData)) == false);
205
206 data.remove(index);
207 assertTrue("Didn't expect removed data in containsKey", data.containsKey(index) == false);
208 }
209
210 public void testContainsValueObject()
211 throws Exception
212 {
213 String[] itemNames = new String[] { "name1", "name2" };
214 String[] itemDescriptions = new String[] { "desc1", "desc2" };
215 OpenType[] itemTypes = new OpenType[] { SimpleType.STRING, SimpleType.INTEGER };
216 CompositeType rowType = new CompositeType("rowTypeName", "rowDescription",
217 itemNames, itemDescriptions, itemTypes);
218
219 String[] indexNames = new String[] { "name1", "name2" };
220 TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);
221
222 TabularDataSupport data = new TabularDataSupport(tabularType);
223
224 assertTrue("Didn't expect containsValue null", data.containsValue(null) == false);
225
226 itemNames = new String[] { "name1", "name2" };
227 itemDescriptions = new String[] { "desc1", "desc2" };
228 itemTypes = new OpenType[] { SimpleType.STRING, SimpleType.INTEGER };
229 CompositeType rowType2 = new CompositeType("rowTypeName2", "rowDescription",
230 itemNames, itemDescriptions, itemTypes);
231
232 HashMap map = new HashMap();
233 map.put("name1", "value1");
234 map.put("name2", new Integer(2));
235 CompositeDataSupport compData2 = new CompositeDataSupport(rowType2, map);
236
237 assertTrue("Didn't expect containsValue wrong composite type", data.containsValue((Object) compData2) == false);
238
239 map = new HashMap();
240 map.put("name1", "value1");
241 map.put("name2", new Integer(3));
242 CompositeDataSupport compData = new CompositeDataSupport(rowType, map);
243 assertTrue("Didn't expect containsValue on data not present", data.containsValue((Object) compData) == false);
244
245 map = new HashMap();
246 map.put("name1", "value1");
247 map.put("name2", new Integer(2));
248 compData = new CompositeDataSupport(rowType, map);
249 data.put(compData);
250 assertTrue("Expected containsValue", data.containsValue((Object) compData));
251
252 map = new HashMap();
253 map.put("name1", "value1");
254 map.put("name2", new Integer(3));
255 compData = new CompositeDataSupport(rowType, map);
256 assertTrue("Didn't expect containsValue on value still not present", data.containsValue((Object) compData) == false);
257
258 assertTrue("Didn't expect containsValue still wrong composite type", data.containsValue((Object) compData2) == false);
259
260 data.remove(data.calculateIndex(compData));
261 assertTrue("Didn't expect removed data in containsValue", data.containsValue((Object) compData) == false);
262 }
263
264 public void testContainsValueCompositeData()
265 throws Exception
266 {
267 String[] itemNames = new String[] { "name1", "name2" };
268 String[] itemDescriptions = new String[] { "desc1", "desc2" };
269 OpenType[] itemTypes = new OpenType[] { SimpleType.STRING, SimpleType.INTEGER };
270 CompositeType rowType = new CompositeType("rowTypeName", "rowDescription",
271 itemNames, itemDescriptions, itemTypes);
272
273 String[] indexNames = new String[] { "name1", "name2" };
274 TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);
275
276 TabularDataSupport data = new TabularDataSupport(tabularType);
277
278 assertTrue("Didn't expect containsValue null", data.containsValue(null) == false);
279
280 itemNames = new String[] { "name1", "name2" };
281 itemDescriptions = new String[] { "desc1", "desc2" };
282 itemTypes = new OpenType[] { SimpleType.STRING, SimpleType.INTEGER };
283 CompositeType rowType2 = new CompositeType("rowTypeName2", "rowDescription",
284 itemNames, itemDescriptions, itemTypes);
285
286 HashMap map = new HashMap();
287 map.put("name1", "value1");
288 map.put("name2", new Integer(2));
289 CompositeDataSupport compData2 = new CompositeDataSupport(rowType2, map);
290
291 assertTrue("Didn't expect containsValue wrong composite type", data.containsValue(compData2) == false);
292
293 map = new HashMap();
294 map.put("name1", "value1");
295 map.put("name2", new Integer(3));
296 CompositeDataSupport compData = new CompositeDataSupport(rowType, map);
297 assertTrue("Didn't expect containsValue on data not present", data.containsValue(compData) == false);
298
299 map = new HashMap();
300 map.put("name1", "value1");
301 map.put("name2", new Integer(2));
302 compData = new CompositeDataSupport(rowType, map);
303 data.put(compData);
304 assertTrue("Expected containsValue", data.containsValue(compData));
305
306 map = new HashMap();
307 map.put("name1", "value1");
308 map.put("name2", new Integer(3));
309 compData = new CompositeDataSupport(rowType, map);
310 assertTrue("Didn't expect containsValue on value still not present", data.containsValue(compData) == false);
311
312 assertTrue("Didn't expect containsValue still wrong composite type", data.containsValue(compData2) == false);
313
314 data.remove(data.calculateIndex(compData));
315 assertTrue("Didn't expect removed data in containsValue", data.containsValue(compData) == false);
316 }
317
318 public void testGetObject()
319 throws Exception
320 {
321 String[] itemNames = new String[] { "name1", "name2" };
322 String[] itemDescriptions = new String[] { "desc1", "desc2" };
323 OpenType[] itemTypes = new OpenType[] { SimpleType.STRING, SimpleType.INTEGER };
324 CompositeType rowType = new CompositeType("rowTypeName", "rowDescription",
325 itemNames, itemDescriptions, itemTypes);
326
327 String[] indexNames = new String[] { "name1", "name2" };
328 TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);
329
330 TabularDataSupport data = new TabularDataSupport(tabularType);
331
332 Object[] index = new Object[] { "value1", new Integer(3) };
333 assertTrue("Expected null for get on data not present", data.get((Object) index) == null);
334
335 HashMap map = new HashMap();
336 map.put("name1", "value1");
337 map.put("name2", new Integer(2));
338 CompositeDataSupport compData = new CompositeDataSupport(rowType, map);
339 index = new Object[] { "value1", new Integer(2) };
340 data.put(compData);
341 assertTrue("Expected get to return the same value", data.get((Object) index).equals(compData));
342
343 index = new Object[] { "value1", new Integer(3) };
344 assertTrue("Didn't expect get on value still not present", data.get((Object) index) == null);
345
346 index = new Object[] { "value1", new Integer(2) };
347 data.remove(index);
348 assertTrue("Didn't expect removed data in get", data.get((Object) index) == null);
349 }
350
351 public void testGetObjectArray()
352 throws Exception
353 {
354 String[] itemNames = new String[] { "name1", "name2" };
355 String[] itemDescriptions = new String[] { "desc1", "desc2" };
356 OpenType[] itemTypes = new OpenType[] { SimpleType.STRING, SimpleType.INTEGER };
357 CompositeType rowType = new CompositeType("rowTypeName", "rowDescription",
358 itemNames, itemDescriptions, itemTypes);
359
360 String[] indexNames = new String[] { "name1", "name2" };
361 TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);
362
363 TabularDataSupport data = new TabularDataSupport(tabularType);
364
365 Object[] index = new Object[] { "value1", new Integer(3) };
366 assertTrue("Expected null for get on data not present", data.get(index) == null);
367
368 HashMap map = new HashMap();
369 map.put("name1", "value1");
370 map.put("name2", new Integer(2));
371 CompositeDataSupport compData = new CompositeDataSupport(rowType, map);
372 index = new Object[] { "value1", new Integer(2) };
373 data.put(compData);
374 assertTrue("Expected get to return the same value", data.get(index).equals(compData));
375
376 index = new Object[] { "value1", new Integer(3) };
377 assertTrue("Didn't expect get on value still not present", data.get(index) == null);
378
379 index = new Object[] { "value1", new Integer(2) };
380 data.remove(index);
381 assertTrue("Didn't expect removed data in get", data.get(index) == null);
382 }
383
384 public void testPutObjectObject()
385 throws Exception
386 {
387 String[] itemNames = new String[] { "name1", "name2" };
388 String[] itemDescriptions = new String[] { "desc1", "desc2" };
389 OpenType[] itemTypes = new OpenType[] { SimpleType.STRING, SimpleType.INTEGER };
390 CompositeType rowType = new CompositeType("rowTypeName", "rowDescription",
391 itemNames, itemDescriptions, itemTypes);
392
393 String[] indexNames = new String[] { "name1", "name2" };
394 TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);
395
396 TabularDataSupport data = new TabularDataSupport(tabularType);
397
398 HashMap map = new HashMap();
399 map.put("name1", "value1");
400 map.put("name2", new Integer(2));
401 CompositeDataSupport compData = new CompositeDataSupport(rowType, map);
402 Object[] index = new Object[] { "value1", new Integer(2) };
403 data.put(index, (Object) compData);
404 assertTrue("The data should be present after put", data.get(index).equals(compData));
405
406 HashMap map2 = new HashMap();
407 map2.put("name1", "value1");
408 map2.put("name2", new Integer(3));
409 CompositeDataSupport compData2 = new CompositeDataSupport(rowType, map2);
410 index = new Object[] { "value1", new Integer(3) };
411 data.put(index, (Object) compData2);
412 assertTrue("Another data should be present after put", data.get(index).equals(compData2));
413
414 index = new Object[] { "value1", new Integer(2) };
415 assertTrue("The previous data should be present after put", data.get(index).equals(compData));
416
417 data.remove(index);
418 data.put(index, compData);
419 assertTrue("Data should be present after remove/put", data.get(index).equals(compData));
420
421 HashMap map3 = new HashMap();
422 map3.put("name1", "value1");
423 map3.put("name2", new Integer(4));
424 CompositeDataSupport compData3 = new CompositeDataSupport(rowType, map3);
425 index = new Object[] { "value1", new Integer(4) };
426 data.put(new Object(), compData3);
427 assertTrue("The key should be ignored in put", data.get(index).equals(compData3));
428 }
429
430 public void testPutCompositeData()
431 throws Exception
432 {
433 String[] itemNames = new String[] { "name1", "name2" };
434 String[] itemDescriptions = new String[] { "desc1", "desc2" };
435 OpenType[] itemTypes = new OpenType[] { SimpleType.STRING, SimpleType.INTEGER };
436 CompositeType rowType = new CompositeType("rowTypeName", "rowDescription",
437 itemNames, itemDescriptions, itemTypes);
438
439 String[] indexNames = new String[] { "name1", "name2" };
440 TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);
441
442 TabularDataSupport data = new TabularDataSupport(tabularType);
443
444 HashMap map = new HashMap();
445 map.put("name1", "value1");
446 map.put("name2", new Integer(2));
447 CompositeDataSupport compData = new CompositeDataSupport(rowType, map);
448 Object[] index = new Object[] { "value1", new Integer(2) };
449 data.put(compData);
450 assertTrue("The data should be present after put", data.get(index).equals(compData));
451
452 HashMap map2 = new HashMap();
453 map2.put("name1", "value1");
454 map2.put("name2", new Integer(3));
455 CompositeDataSupport compData2 = new CompositeDataSupport(rowType, map2);
456 index = new Object[] { "value1", new Integer(3) };
457 data.put(compData2);
458 assertTrue("Another data should be present after put", data.get(index).equals(compData2));
459
460 index = new Object[] { "value1", new Integer(2) };
461 assertTrue("The previous data should be present after put", data.get(index).equals(compData));
462
463 data.remove(index);
464 data.put(compData);
465 assertTrue("Data should be present after remove/put", data.get(index).equals(compData));
466 }
467
468 public void testRemoveObject()
469 throws Exception
470 {
471 String[] itemNames = new String[] { "name1", "name2" };
472 String[] itemDescriptions = new String[] { "desc1", "desc2" };
473 OpenType[] itemTypes = new OpenType[] { SimpleType.STRING, SimpleType.INTEGER };
474 CompositeType rowType = new CompositeType("rowTypeName", "rowDescription",
475 itemNames, itemDescriptions, itemTypes);
476
477 String[] indexNames = new String[] { "name1", "name2" };
478 TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);
479
480 TabularDataSupport data = new TabularDataSupport(tabularType);
481
482 HashMap map = new HashMap();
483 map.put("name1", "value1");
484 map.put("name2", new Integer(2));
485 CompositeDataSupport compData = new CompositeDataSupport(rowType, map);
486 Object[] index = new Object[] { "value1", new Integer(2) };
487
488 assertTrue("Remove on data not present returns null", data.remove((Object) index) == null);
489
490 data.put(compData);
491 assertTrue("Remove on data present returns the data", data.remove((Object) index).equals(compData));
492 }
493
494 public void testRemoveObjectArray()
495 throws Exception
496 {
497 String[] itemNames = new String[] { "name1", "name2" };
498 String[] itemDescriptions = new String[] { "desc1", "desc2" };
499 OpenType[] itemTypes = new OpenType[] { SimpleType.STRING, SimpleType.INTEGER };
500 CompositeType rowType = new CompositeType("rowTypeName", "rowDescription",
501 itemNames, itemDescriptions, itemTypes);
502
503 String[] indexNames = new String[] { "name1", "name2" };
504 TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);
505
506 TabularDataSupport data = new TabularDataSupport(tabularType);
507
508 HashMap map = new HashMap();
509 map.put("name1", "value1");
510 map.put("name2", new Integer(2));
511 CompositeDataSupport compData = new CompositeDataSupport(rowType, map);
512 Object[] index = new Object[] { "value1", new Integer(2) };
513
514 assertTrue("Remove on data not present returns null", data.remove(index) == null);
515
516 data.put(compData);
517 assertTrue("Remove on data present returns the data", data.remove(index).equals(compData));
518 }
519
520 public void testPutAllMap()
521 throws Exception
522 {
523 String[] itemNames = new String[] { "name1", "name2" };
524 String[] itemDescriptions = new String[] { "desc1", "desc2" };
525 OpenType[] itemTypes = new OpenType[] { SimpleType.STRING, SimpleType.INTEGER };
526 CompositeType rowType = new CompositeType("rowTypeName", "rowDescription",
527 itemNames, itemDescriptions, itemTypes);
528
529 String[] indexNames = new String[] { "name1", "name2" };
530 TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);
531
532 TabularDataSupport data = new TabularDataSupport(tabularType);
533
534 data.putAll((Map) null);
535 assertTrue("Put all null is ok", data.isEmpty());
536
537 HashMap map = new HashMap();
538 map.put("name1", "value1");
539 map.put("name2", new Integer(2));
540 CompositeDataSupport compData = new CompositeDataSupport(rowType, map);
541
542 HashMap toPut = new HashMap();
543 toPut.put(new Object(), compData);
544 data.putAll(toPut);
545 assertTrue("Put all added one", data.size() == 1);
546 assertTrue("Put all added the correct data", data.containsValue(compData));
547
548 HashMap map2 = new HashMap();
549 map2.put("name1", "value1");
550 map2.put("name2", new Integer(3));
551 CompositeDataSupport compData2 = new CompositeDataSupport(rowType, map2);
552
553 HashMap map3 = new HashMap();
554 map3.put("name1", "value1");
555 map3.put("name2", new Integer(4));
556 CompositeDataSupport compData3 = new CompositeDataSupport(rowType, map3);
557
558 toPut = new HashMap();
559 toPut.put(new Object(), compData2);
560 toPut.put(new Object(), compData3);
561 data.putAll(toPut);
562 assertTrue("Put all added two", data.size() == 3);
563 assertTrue("Put all added the correct data", data.containsValue(compData2));
564 assertTrue("Put all added the correct data", data.containsValue(compData3));
565 assertTrue("Put all original data still present", data.containsValue(compData));
566 }
567
568 public void testPutAllCompositeData()
569 throws Exception
570 {
571 String[] itemNames = new String[] { "name1", "name2" };
572 String[] itemDescriptions = new String[] { "desc1", "desc2" };
573 OpenType[] itemTypes = new OpenType[] { SimpleType.STRING, SimpleType.INTEGER };
574 CompositeType rowType = new CompositeType("rowTypeName", "rowDescription",
575 itemNames, itemDescriptions, itemTypes);
576
577 String[] indexNames = new String[] { "name1", "name2" };
578 TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);
579
580 TabularDataSupport data = new TabularDataSupport(tabularType);
581
582 data.putAll((CompositeData[]) null);
583 assertTrue("Put all null is ok", data.isEmpty());
584
585 HashMap map = new HashMap();
586 map.put("name1", "value1");
587 map.put("name2", new Integer(2));
588 CompositeDataSupport compData = new CompositeDataSupport(rowType, map);
589
590 CompositeData[] toPut = new CompositeData[] { compData };
591 data.putAll(toPut);
592 assertTrue("Put all added one", data.size() == 1);
593 assertTrue("Put all added the correct data", data.containsValue(compData));
594
595 HashMap map2 = new HashMap();
596 map2.put("name1", "value1");
597 map2.put("name2", new Integer(3));
598 CompositeDataSupport compData2 = new CompositeDataSupport(rowType, map2);
599
600 HashMap map3 = new HashMap();
601 map3.put("name1", "value1");
602 map3.put("name2", new Integer(4));
603 CompositeDataSupport compData3 = new CompositeDataSupport(rowType, map3);
604
605 toPut = new CompositeData[] { compData2, compData3 };
606 data.putAll(toPut);
607 assertTrue("Put all added two", data.size() == 3);
608 assertTrue("Put all added the correct data", data.containsValue(compData2));
609 assertTrue("Put all added the correct data", data.containsValue(compData3));
610 assertTrue("Put all original data still present", data.containsValue(compData));
611 }
612
613 public void testClear()
614 throws Exception
615 {
616 String[] itemNames = new String[] { "name1", "name2" };
617 String[] itemDescriptions = new String[] { "desc1", "desc2" };
618 OpenType[] itemTypes = new OpenType[] { SimpleType.STRING, SimpleType.INTEGER };
619 CompositeType rowType = new CompositeType("rowTypeName", "rowDescription",
620 itemNames, itemDescriptions, itemTypes);
621
622 String[] indexNames = new String[] { "name1", "name2" };
623 TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);
624
625 TabularDataSupport data = new TabularDataSupport(tabularType);
626
627 data.putAll((CompositeData[]) null);
628 assertTrue("Put all null is ok", data.isEmpty());
629
630 HashMap map = new HashMap();
631 map.put("name1", "value1");
632 map.put("name2", new Integer(2));
633 CompositeDataSupport compData = new CompositeDataSupport(rowType, map);
634
635 HashMap map2 = new HashMap();
636 map2.put("name1", "value1");
637 map2.put("name2", new Integer(3));
638 CompositeDataSupport compData2 = new CompositeDataSupport(rowType, map2);
639
640 HashMap map3 = new HashMap();
641 map3.put("name1", "value1");
642 map3.put("name2", new Integer(4));
643 CompositeDataSupport compData3 = new CompositeDataSupport(rowType, map3);
644
645 HashMap toPut = new HashMap();
646 toPut.put(new Object(), compData);
647 toPut.put(new Object(), compData2);
648 toPut.put(new Object(), compData3);
649 data.putAll(toPut);
650
651 data.clear();
652 assertTrue("Clear should clear the data", data.isEmpty());
653 }
654
655 public void testSize()
656 throws Exception
657 {
658 String[] itemNames = new String[] { "name1", "name2" };
659 String[] itemDescriptions = new String[] { "desc1", "desc2" };
660 OpenType[] itemTypes = new OpenType[] { SimpleType.STRING, SimpleType.INTEGER };
661 CompositeType rowType = new CompositeType("rowTypeName", "rowDescription",
662 itemNames, itemDescriptions, itemTypes);
663
664 String[] indexNames = new String[] { "name1", "name2" };
665 TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);
666
667 TabularDataSupport data = new TabularDataSupport(tabularType);
668
669 assertTrue("Initial size is zero", data.size() == 0);
670
671 HashMap map = new HashMap();
672 map.put("name1", "value1");
673 map.put("name2", new Integer(2));
674 CompositeDataSupport compData = new CompositeDataSupport(rowType, map);
675
676 CompositeData[] toPut = new CompositeData[] { compData };
677 data.putAll(toPut);
678 assertTrue("Expected one element", data.size() == 1);
679
680 HashMap map2 = new HashMap();
681 map2.put("name1", "value1");
682 map2.put("name2", new Integer(3));
683 CompositeDataSupport compData2 = new CompositeDataSupport(rowType, map2);
684
685 HashMap map3 = new HashMap();
686 map3.put("name1", "value1");
687 map3.put("name2", new Integer(4));
688 CompositeDataSupport compData3 = new CompositeDataSupport(rowType, map3);
689
690 toPut = new CompositeData[] { compData2, compData3 };
691 data.putAll(toPut);
692 assertTrue("Expected three elements", data.size() == 3);
693
694 data.remove(new Object[] { "value1", new Integer(4) });
695 assertTrue("Expected two elements", data.size() == 2);
696
697 data.clear();
698 assertTrue("Expected no elements", data.size() == 0);
699 }
700
701 public void testIsEmpty()
702 throws Exception
703 {
704 String[] itemNames = new String[] { "name1", "name2" };
705 String[] itemDescriptions = new String[] { "desc1", "desc2" };
706 OpenType[] itemTypes = new OpenType[] { SimpleType.STRING, SimpleType.INTEGER };
707 CompositeType rowType = new CompositeType("rowTypeName", "rowDescription",
708 itemNames, itemDescriptions, itemTypes);
709
710 String[] indexNames = new String[] { "name1", "name2" };
711 TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);
712
713 TabularDataSupport data = new TabularDataSupport(tabularType);
714
715 assertTrue("Initially empty", data.isEmpty());
716
717 HashMap map = new HashMap();
718 map.put("name1", "value1");
719 map.put("name2", new Integer(2));
720 CompositeDataSupport compData = new CompositeDataSupport(rowType, map);
721
722 CompositeData[] toPut = new CompositeData[] { compData };
723 data.putAll(toPut);
724 assertTrue("Not empty after a put", data.isEmpty() == false);
725
726 data.clear();
727 assertTrue("Expected no elements", data.isEmpty());
728 }
729
730
733 public void testKeySet()
734 throws Exception
735 {
736 String[] itemNames = new String[] { "name1", "name2" };
737 |
Java API By Example, From Geeks To Geeks.