1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 package org.apache.commons.beanutils;
19
20
21 import java.io.ByteArrayInputStream;
22 import java.io.ByteArrayOutputStream;
23 import java.io.ObjectInputStream;
24 import java.io.ObjectOutputStream;
25
26 import java.util.ArrayList;
27 import java.util.HashMap;
28 import java.util.List;
29 import java.util.Map;
30
31 import junit.framework.TestCase;
32 import junit.framework.Test;
33 import junit.framework.TestSuite;
34
35
36 /**
37 * <p>Test Case for the <code>BasicDynaBean</code> implementation class.
38 * These tests were based on the ones in <code>PropertyUtilsTestCase</code>
39 * because the two classes provide similar levels of functionality.</p>
40 *
41 * @author Craig R. McClanahan
42 * @version $Revision: 1.10 $ $Date: 2004/02/28 13:18:36 $
43 */
44
45 public class BasicDynaBeanTestCase extends TestCase {
46
47
48
49
50
51 /**
52 * The basic test bean for each test.
53 */
54 protected DynaBean bean = null;
55
56
57 /**
58 * The set of property names we expect to have returned when calling
59 * <code>getDynaProperties()</code>. You should update this list
60 * when new properties are added to TestBean.
61 */
62 protected final static String[] properties = {
63 "booleanProperty",
64 "booleanSecond",
65 "doubleProperty",
66 "floatProperty",
67 "intArray",
68 "intIndexed",
69 "intProperty",
70 "listIndexed",
71 "longProperty",
72 "mappedProperty",
73 "mappedIntProperty",
74 "nullProperty",
75 "shortProperty",
76 "stringArray",
77 "stringIndexed",
78 "stringProperty",
79 };
80
81
82
83
84
85 /**
86 * Construct a new instance of this test case.
87 *
88 * @param name Name of the test case
89 */
90 public BasicDynaBeanTestCase(String name) {
91
92 super(name);
93
94 }
95
96
97
98
99
100 /**
101 * Set up instance variables required by this test case.
102 */
103 public void setUp() throws Exception {
104
105
106 DynaClass dynaClass = createDynaClass();
107 bean = dynaClass.newInstance();
108
109
110 bean.set("booleanProperty", new Boolean(true));
111 bean.set("booleanSecond", new Boolean(true));
112 bean.set("doubleProperty", new Double(321.0));
113 bean.set("floatProperty", new Float((float) 123.0));
114 int intArray[] = { 0, 10, 20, 30, 40 };
115 bean.set("intArray", intArray);
116 int intIndexed[] = { 0, 10, 20, 30, 40 };
117 bean.set("intIndexed", intIndexed);
118 bean.set("intProperty", new Integer(123));
119 List listIndexed = new ArrayList();
120 listIndexed.add("String 0");
121 listIndexed.add("String 1");
122 listIndexed.add("String 2");
123 listIndexed.add("String 3");
124 listIndexed.add("String 4");
125 bean.set("listIndexed", listIndexed);
126 bean.set("longProperty", new Long((long) 321));
127 HashMap mappedProperty = new HashMap();
128 mappedProperty.put("First Key", "First Value");
129 mappedProperty.put("Second Key", "Second Value");
130 bean.set("mappedProperty", mappedProperty);
131 HashMap mappedIntProperty = new HashMap();
132 mappedIntProperty.put("One", new Integer(1));
133 mappedIntProperty.put("Two", new Integer(2));
134 bean.set("mappedIntProperty", mappedIntProperty);
135
136 bean.set("shortProperty", new Short((short) 987));
137 String stringArray[] =
138 { "String 0", "String 1", "String 2", "String 3", "String 4" };
139 bean.set("stringArray", stringArray);
140 String stringIndexed[] =
141 { "String 0", "String 1", "String 2", "String 3", "String 4" };
142 bean.set("stringIndexed", stringIndexed);
143 bean.set("stringProperty", "This is a string");
144
145 }
146
147
148 /**
149 * Return the tests included in this test suite.
150 */
151 public static Test suite() {
152
153 return (new TestSuite(BasicDynaBeanTestCase.class));
154
155 }
156
157
158 /**
159 * Tear down instance variables required by this test case.
160 */
161 public void tearDown() {
162
163 bean = null;
164
165 }
166
167
168
169
170
171
172 /**
173 * Corner cases on getDynaProperty invalid arguments.
174 */
175 public void testGetDescriptorArguments() {
176
177 try {
178 DynaProperty descriptor =
179 bean.getDynaClass().getDynaProperty("unknown");
180 assertNull("Unknown property descriptor should be null",
181 descriptor);
182 } catch (Throwable t) {
183 fail("Threw " + t + " instead of returning null");
184 }
185
186 try {
187 bean.getDynaClass().getDynaProperty(null);
188 fail("Should throw IllegalArgumentException");
189 } catch (IllegalArgumentException e) {
190 ;
191 } catch (Throwable t) {
192 fail("Threw " + t + " instead of IllegalArgumentException");
193 }
194
195 }
196
197
198 /**
199 * Positive getDynaProperty on property <code>booleanProperty</code>.
200 */
201 public void testGetDescriptorBoolean() {
202
203 testGetDescriptorBase("booleanProperty", Boolean.TYPE);
204
205 }
206
207
208 /**
209 * Positive getDynaProperty on property <code>doubleProperty</code>.
210 */
211 public void testGetDescriptorDouble() {
212
213 testGetDescriptorBase("doubleProperty", Double.TYPE);
214
215 }
216
217
218 /**
219 * Positive getDynaProperty on property <code>floatProperty</code>.
220 */
221 public void testGetDescriptorFloat() {
222
223 testGetDescriptorBase("floatProperty", Float.TYPE);
224
225 }
226
227
228 /**
229 * Positive getDynaProperty on property <code>intProperty</code>.
230 */
231 public void testGetDescriptorInt() {
232
233 testGetDescriptorBase("intProperty", Integer.TYPE);
234
235 }
236
237
238 /**
239 * Positive getDynaProperty on property <code>longProperty</code>.
240 */
241 public void testGetDescriptorLong() {
242
243 testGetDescriptorBase("longProperty", Long.TYPE);
244
245 }
246
247
248 /**
249 * Positive getDynaProperty on property <code>booleanSecond</code>
250 * that uses an "is" method as the getter.
251 */
252 public void testGetDescriptorSecond() {
253
254 testGetDescriptorBase("booleanSecond", Boolean.TYPE);
255
256 }
257
258
259 /**
260 * Positive getDynaProperty on property <code>shortProperty</code>.
261 */
262 public void testGetDescriptorShort() {
263
264 testGetDescriptorBase("shortProperty", Short.TYPE);
265
266 }
267
268
269 /**
270 * Positive getDynaProperty on property <code>stringProperty</code>.
271 */
272 public void testGetDescriptorString() {
273
274 testGetDescriptorBase("stringProperty", String.class);
275
276 }
277
278
279 /**
280 * Positive test for getDynaPropertys(). Each property name
281 * listed in <code>properties</code> should be returned exactly once.
282 */
283 public void testGetDescriptors() {
284
285 DynaProperty pd[] = bean.getDynaClass().getDynaProperties();
286 assertNotNull("Got descriptors", pd);
287 int count[] = new int[properties.length];
288 for (int i = 0; i < pd.length; i++) {
289 String name = pd[i].getName();
290 for (int j = 0; j < properties.length; j++) {
291 if (name.equals(properties[j]))
292 count[j]++;
293 }
294 }
295 for (int j = 0; j < properties.length; j++) {
296 if (count[j] < 0)
297 fail("Missing property " + properties[j]);
298 else if (count[j] > 1)
299 fail("Duplicate property " + properties[j]);
300 }
301
302 }
303
304
305 /**
306 * Corner cases on getIndexedProperty invalid arguments.
307 */
308 public void testGetIndexedArguments() {
309
310 try {
311 bean.get("intArray", -1);
312 fail("Should throw IndexOutOfBoundsException");
313 } catch (IndexOutOfBoundsException e) {
314 ;
315 } catch (Throwable t) {
316 fail("Threw " + t + " instead of IndexOutOfBoundsException");
317 }
318
319
320 }
321
322
323 /**
324 * Positive and negative tests on getIndexedProperty valid arguments.
325 */
326 public void testGetIndexedValues() {
327
328 Object value = null;
329
330 for (int i = 0; i < 5; i++) {
331
332 try {
333 value = bean.get("intArray", i);
334 assertNotNull("intArray returned value " + i, value);
335 assertTrue("intArray returned Integer " + i,
336 value instanceof Integer);
337 assertEquals("intArray returned correct " + i, i * 10,
338 ((Integer) value).intValue());
339 } catch (Throwable t) {
340 fail("intArray " + i + " threw " + t);
341 }
342
343 try {
344 value = bean.get("intIndexed", i);
345 assertNotNull("intIndexed returned value " + i, value);
346 assertTrue("intIndexed returned Integer " + i,
347 value instanceof Integer);
348 assertEquals("intIndexed returned correct " + i, i * 10,
349 ((Integer) value).intValue());
350 } catch (Throwable t) {
351 fail("intIndexed " + i + " threw " + t);
352 }
353
354 try {
355 value = bean.get("listIndexed", i);
356 assertNotNull("listIndexed returned value " + i, value);
357 assertTrue("list returned String " + i,
358 value instanceof String);
359 assertEquals("listIndexed returned correct " + i,
360 "String " + i, (String) value);
361 } catch (Throwable t) {
362 fail("listIndexed " + i + " threw " + t);
363 }
364
365 try {
366 value = bean.get("stringArray", i);
367 assertNotNull("stringArray returned value " + i, value);
368 assertTrue("stringArray returned String " + i,
369 value instanceof String);
370 assertEquals("stringArray returned correct " + i,
371 "String " + i, (String) value);
372 } catch (Throwable t) {
373 fail("stringArray " + i + " threw " + t);
374 }
375
376 try {
377 value = bean.get("stringIndexed", i);
378 assertNotNull("stringIndexed returned value " + i, value);
379 assertTrue("stringIndexed returned String " + i,
380 value instanceof String);
381 assertEquals("stringIndexed returned correct " + i,
382 "String " + i, (String) value);
383 } catch (Throwable t) {
384 fail("stringIndexed " + i + " threw " + t);
385 }
386
387 }
388
389
390 }
391
392
393 /**
394 * Corner cases on getMappedProperty invalid arguments.
395 */
396 public void testGetMappedArguments() {
397
398
399 try {
400 Object value = bean.get("mappedProperty", "unknown");
401 assertNull("Should not return a value", value);
402 } catch (Throwable t) {
403 fail("Threw " + t + " instead of returning null");
404 }
405
406
407 }
408
409
410 /**
411 * Positive and negative tests on getMappedProperty valid arguments.
412 */
413 public void testGetMappedValues() {
414
415 Object value = null;
416
417 try {
418 value = bean.get("mappedProperty", "First Key");
419 assertEquals("Can find first value", "First Value", value);
420 } catch (Throwable t) {
421 fail("Finding first value threw " + t);
422 }
423
424 try {
425 value = bean.get("mappedProperty", "Second Key");
426 assertEquals("Can find second value", "Second Value", value);
427 } catch (Throwable t) {
428 fail("Finding second value threw " + t);
429 }
430
431 try {
432 value = bean.get("mappedProperty", "Third Key");
433 assertNull("Can not find third value", value);
434 } catch (Throwable t) {
435 fail("Finding third value threw " + t);
436 }
437
438 }
439
440
441 /**
442 * Corner cases on getSimpleProperty invalid arguments.
443 */
444 public void testGetSimpleArguments() {
445
446 try {
447 bean.get(null);
448 fail("Should throw IllegalArgumentException");
449 } catch (IllegalArgumentException e) {
450 ;
451 } catch (Throwable t) {
452 fail("Threw " + t + " instead of IllegalArgumentException");
453 }
454
455 }
456
457
458 /**
459 * Test getSimpleProperty on a boolean property.
460 */
461 public void testGetSimpleBoolean() {
462
463 try {
464 Object value = bean.get("booleanProperty");
465 assertNotNull("Got a value", value);
466 assertTrue("Got correct type", (value instanceof Boolean));
467 assertTrue("Got correct value",
468 ((Boolean) value).booleanValue() == true);
469 } catch (Throwable e) {
470 fail("Exception: " + e);
471 }
472
473 }
474
475
476 /**
477 * Test getSimpleProperty on a double property.
478 */
479 public void testGetSimpleDouble() {
480
481 try {
482 Object value = bean.get("doubleProperty");
483 assertNotNull("Got a value", value);
484 assertTrue("Got correct type", (value instanceof Double));
485 assertEquals("Got correct value",
486 ((Double) value).doubleValue(),
487 (double) 321.0,
488 (double) 0.005);
489 } catch (Throwable t) {
490 fail("Exception: " + t);
491 }
492
493 }
494
495
496 /**
497 * Test getSimpleProperty on a float property.
498 */
499 public void testGetSimpleFloat() {
500
501 try {
502 Object value = bean.get("floatProperty");
503 assertNotNull("Got a value", value);
504 assertTrue("Got correct type", (value instanceof Float));
505 assertEquals("Got correct value",
506 ((Float) value).floatValue(),
507 (float) 123.0,
508 (float) 0.005);
509 } catch (Throwable t) {
510 fail("Exception: " + t);
511 }
512
513 }
514
515
516 /**
517 * Test getSimpleProperty on a int property.
518 */
519 public void testGetSimpleInt() {
520
521 try {
522 Object value = bean.get("intProperty");
523 assertNotNull("Got a value", value);
524 assertTrue("Got correct type", (value instanceof Integer));
525 assertEquals("Got correct value",
526 ((Integer) value).intValue(),
527 (int) 123);
528 } catch (Throwable t) {
529 fail("Exception: " + t);
530 }
531
532 }
533
534
535 /**
536 * Test getSimpleProperty on a long property.
537 */
538 public void testGetSimpleLong() {
539
540 try {
541 Object value = bean.get("longProperty");
542 assertNotNull("Got a value", value);
543 assertTrue("Got correct type", (value instanceof Long));
544 assertEquals("Got correct value",
545 ((Long) value).longValue(),
546 (long) 321);
547 } catch (Throwable t) {
548 fail("Exception: " + t);
549 }
550
551 }
552
553
554 /**
555 * Test getSimpleProperty on a short property.
556 */
557 public void testGetSimpleShort() {
558
559 try {
560 Object value = bean.get("shortProperty");
561 assertNotNull("Got a value", value);
562 assertTrue("Got correct type", (value instanceof Short));
563 assertEquals("Got correct value",
564 ((Short) value).shortValue(),
565 (short) 987);
566 } catch (Throwable t) {
567 fail("Exception: " + t);
568 }
569
570 }
571
572
573 /**
574 * Test getSimpleProperty on a String property.
575 */
576 public void testGetSimpleString() {
577
578 try {
579 Object value = bean.get("stringProperty");
580 assertNotNull("Got a value", value);
581 assertTrue("Got correct type", (value instanceof String));
582 assertEquals("Got correct value",
583 (String) value,
584 "This is a string");
585 } catch (Throwable t) {
586 fail("Exception: " + t);
587 }
588
589 }
590
591
592 /**
593 * Test <code>contains()</code> method for mapped properties.
594 */
595 public void testMappedContains() {
596
597 try {
598 assertTrue("Can see first key",
599 bean.contains("mappedProperty", "First Key"));
600 } catch (Throwable t) {
601 fail("Exception: " + t);
602 }
603
604
605 try {
606 assertTrue("Can not see unknown key",
607 !bean.contains("mappedProperty", "Unknown Key"));
608 } catch (Throwable t) {
609 fail("Exception: " + t);
610 }
611
612 }
613
614
615 /**
616 * Test <code>remove()</code> method for mapped properties.
617 */
618 public void testMappedRemove() {
619
620 try {
621 assertTrue("Can see first key",
622 bean.contains("mappedProperty", "First Key"));
623 bean.remove("mappedProperty", "First Key");
624 assertTrue("Can not see first key",
625 !bean.contains("mappedProperty", "First Key"));
626 } catch (Throwable t) {
627 fail("Exception: " + t);
628 }
629
630 try {
631 assertTrue("Can not see unknown key",
632 !bean.contains("mappedProperty", "Unknown Key"));
633 bean.remove("mappedProperty", "Unknown Key");
634 assertTrue("Can not see unknown key",
635 !bean.contains("mappedProperty", "Unknown Key"));
636 } catch (Throwable t) {
637 fail("Exception: " + t);
638 }
639
640 }
641
642
643 /**
644 * Test serialization and deserialization.
645 */
646 public void testSerialization() {
647
648
649 ByteArrayOutputStream baos = new ByteArrayOutputStream();
650 try {
651 ObjectOutputStream oos = new ObjectOutputStream(baos);
652 oos.writeObject(bean);
653 oos.flush();
654 oos.close();
655 } catch (Exception e) {
656 fail("Exception during serialization: " + e);
657 }
658
659
660 try {
661 bean = null;
662 ByteArrayInputStream bais =
663 new ByteArrayInputStream(baos.toByteArray());
664 ObjectInputStream ois = new ObjectInputStream(bais);
665 bean = (DynaBean) ois.readObject();
666 bais.close();
667 } catch (Exception e) {
668 fail("Exception during deserialization: " + e);
669 }
670
671
672 testGetDescriptorArguments();
673 testGetDescriptorBoolean();
674 testGetDescriptorDouble();
675 testGetDescriptorFloat();
676 testGetDescriptorInt();
677 testGetDescriptorLong();
678 testGetDescriptorSecond();
679 testGetDescriptorShort();
680 testGetDescriptorString();
681 testGetDescriptors();
682 testGetIndexedArguments();
683 testGetIndexedValues();
684 testGetMappedArguments();
685 testGetMappedValues();
686 testGetSimpleArguments();
687 testGetSimpleBoolean();
688 testGetSimpleDouble();
689 testGetSimpleFloat();
690 testGetSimpleInt();
691 testGetSimpleLong();
692 testGetSimpleShort();
693 testGetSimpleString();
694 testMappedContains();
695 testMappedRemove();
696
697
698 try {
699 bean = bean.getDynaClass().newInstance();
700 } catch (Exception e) {
701 fail("Exception creating new instance: " + e);
702 }
703 testGetDescriptorArguments();
704 testGetDescriptorBoolean();
705 testGetDescriptorDouble();
706 testGetDescriptorFloat();
707 testGetDescriptorInt();
708 testGetDescriptorLong();
709 testGetDescriptorSecond();
710 testGetDescriptorShort();
711 testGetDescriptorString();
712 testGetDescriptors();
713
714 }
715
716
717 /**
718 * Corner cases on setIndexedProperty invalid arguments.
719 */
720 public void testSetIndexedArguments() {
721
722 try {
723 bean.set("intArray", -1, new Integer(0));
724 fail("Should throw IndexOutOfBoundsException");
725 } catch (IndexOutOfBoundsException e) {
726 ;
727 } catch (Throwable t) {
728 fail("Threw " + t + " instead of IndexOutOfBoundsException");
729 }
730
731 }
732
733
734 /**
735 * Positive and negative tests on setIndexedProperty valid arguments.
736 */
737 public void testSetIndexedValues() {
738
739 Object value = null;
740
741 try {
742 bean.set("intArray", 0, new Integer(1));
743 value = (Integer) bean.get("intArray", 0);
744 assertNotNull("Returned new value 0", value);
745 assertTrue("Returned Integer new value 0",
746 value instanceof Integer);
747 assertEquals("Returned correct new value 0", 1,
748 ((Integer) value).intValue());
749 } catch (Throwable t) {
750 fail("Threw " + t);
751 }
752
753 try {
754 bean.set("intIndexed", 1, new Integer(11));
755 value = (Integer) bean.get("intIndexed", 1);
756 assertNotNull("Returned new value 1", value);
757 assertTrue("Returned Integer new value 1",
758 value instanceof Integer);
759 assertEquals("Returned correct new value 1", 11,
760 ((Integer) value).intValue());
761 } catch (Throwable t) {
762 fail("Threw " + t);
763 }
764
765 try {
766 bean.set("listIndexed", 2, "New Value 2");
767 value = (String) bean.get("listIndexed", 2);
768 assertNotNull("Returned new value 2", value);
769 assertTrue("Returned String new value 2",
770 value instanceof String);
771 assertEquals("Returned correct new value 2", "New Value 2",
772 (String) value);
773 } catch (Throwable t) {
774 fail("Threw " + t);
775 }
776
777 try {
778 bean.set("stringArray", 3, "New Value 3");
779 value = (String) bean.get("stringArray", 3);
780 assertNotNull("Returned new value 3", value);
781 assertTrue("Returned String new value 3",
782 value instanceof String);
783 assertEquals("Returned correct new value 3", "New Value 3",
784 (String) value);
785 } catch (Throwable t) {
786 fail("Threw " + t);
787 }
788
789 try {
790 bean.set("stringIndexed", 4, "New Value 4");
791 value = (String) bean.get("stringIndexed", 4);
792 assertNotNull("Returned new value 4", value);
793 assertTrue("Returned String new value 4",
794 value instanceof String);
795 assertEquals("Returned correct new value 4", "New Value 4",
796 (String) value);
797 } catch (Throwable t) {
798 fail("Threw " + t);
799 }
800
801
802 }
803
804
805 /**
806 * Positive and negative tests on setMappedProperty valid arguments.
807 */
808 public void testSetMappedValues() {
809
810 try {
811 bean.set("mappedProperty", "First Key", "New First Value");
812 assertEquals("Can replace old value",
813 "New First Value",
814 (String) bean.get("mappedProperty", "First Key"));
815 } catch (Throwable t) {
816 fail("Finding fourth value threw " + t);
817 }
818
819 try {
820 bean.set("mappedProperty", "Fourth Key", "Fourth Value");
821 assertEquals("Can set new value",
822 "Fourth Value",
823 (String) bean.get("mappedProperty", "Fourth Key"));
824 } catch (Throwable t) {
825 fail("Finding fourth value threw " + t);
826 }
827
828
829 }
830
831
832 /**
833 * Test setSimpleProperty on a boolean property.
834 */
835 public void testSetSimpleBoolean() {
836
837 try {
838 boolean oldValue =
839 ((Boolean) bean.get("booleanProperty")).booleanValue();
840 boolean newValue = !oldValue;
841 bean.set("booleanProperty", new Boolean(newValue));
842 assertTrue("Matched new value",
843 newValue ==
844 ((Boolean) bean.get("booleanProperty")).booleanValue());
845 } catch (Throwable e) {
846 fail("Exception: " + e);
847 }
848
849 }
850
851
852 /**
853 * Test setSimpleProperty on a double property.
854 */
855 public void testSetSimpleDouble() {
856
857 try {
858 double oldValue =
859 ((Double) bean.get("doubleProperty")).doubleValue();
860 double newValue = oldValue + 1.0;
861 bean.set("doubleProperty", new Double(newValue));
862 assertEquals("Matched new value",
863 newValue,
864 ((Double) bean.get("doubleProperty")).doubleValue(),
865 (double) 0.005);
866 } catch (Throwable e) {
867 fail("Exception: " + e);
868 }
869
870 }
871
872
873 /**
874 * Test setSimpleProperty on a float property.
875 */
876 public void testSetSimpleFloat() {
877
878 try {
879 float oldValue =
880 ((Float) bean.get("floatProperty")).floatValue();
881 float newValue = oldValue + (float) 1.0;
882 bean.set("floatProperty", new Float(newValue));
883 assertEquals("Matched new value",
884 newValue,
885 ((Float) bean.get("floatProperty")).floatValue(),
886 (float) 0.005);
887 } catch (Throwable e) {
888 fail("Exception: " + e);
889 }
890
891 }
892
893
894 /**
895 * Test setSimpleProperty on a int property.
896 */
897 public void testSetSimpleInt() {
898
899 try {
900 int oldValue =
901 ((Integer) bean.get("intProperty")).intValue();
902 int newValue = oldValue + 1;
903 bean.set("intProperty", new Integer(newValue));
904 assertEquals("Matched new value",
905 newValue,
906 ((Integer) bean.get("intProperty")).intValue());
907 } catch (Throwable e) {
908 fail("Exception: " + e);
909 }
910
911 }
912
913
914 /**
915 * Test setSimpleProperty on a long property.
916 */
917 public void testSetSimpleLong() {
918
919 try {
920 long oldValue =
921 ((Long) bean.get("longProperty")).longValue();
922 long newValue = oldValue + 1;
923 bean.set("longProperty", new Long(newValue));
924 assertEquals("Matched new value",
925 newValue,
926 ((Long) bean.get("longProperty")).longValue());
927 } catch (Throwable e) {
928 fail("Exception: " + e);
929 }
930
931 }
932
933
934 /**
935 * Test setSimpleProperty on a short property.
936 */
937 public void testSetSimpleShort() {
938
939 try {
940 short oldValue =
941 ((Short) bean.get("shortProperty")).shortValue();
942 short newValue = (short) (oldValue + 1);
943 bean.set("shortProperty", new Short(newValue));
944 assertEquals("Matched new value",
945 newValue,
946 ((Short) bean.get("shortProperty")).shortValue());
947 } catch (Throwable e) {
948 fail("Exception: " + e);
949 }
950
951 }
952
953
954 /**
955 * Test setSimpleProperty on a String property.
956 */
957 public void testSetSimpleString() {
958
959 try {
960 String oldValue = (String) bean.get("stringProperty");
961 String newValue = oldValue + " Extra Value";
962 bean.set("stringProperty", newValue);
963 assertEquals("Matched new value",
964 newValue,
965 (String) bean.get("stringProperty"));
966 } catch (Throwable e) {
967 fail("Exception: " + e);
968 }
969
970 }
971
972
973
974
975
976 /**
977 * Create and return a <code>DynaClass</code> instance for our test
978 * <code>DynaBean</code>.
979 */
980 protected DynaClass createDynaClass() {
981
982 int intArray[] = new int[0];
983 String stringArray[] = new String[0];
984
985 DynaClass dynaClass = new BasicDynaClass
986 ("TestDynaClass", null,
987 new DynaProperty[]{
988 new DynaProperty("booleanProperty", Boolean.TYPE),
989 new DynaProperty("booleanSecond", Boolean.TYPE),
990 new DynaProperty("doubleProperty", Double.TYPE),
991 new DynaProperty("floatProperty", Float.TYPE),
992 new DynaProperty("intArray", intArray.getClass()),
993 new DynaProperty("intIndexed", intArray.getClass()),
994 new DynaProperty("intProperty", Integer.TYPE),
995 new DynaProperty("listIndexed", List.class),
996 new DynaProperty("longProperty", Long.TYPE),
997 new DynaProperty("mappedProperty", Map.class),
998 new DynaProperty("mappedIntProperty", Map.class),
999 new DynaProperty("nullProperty", String.class),
1000 new DynaProperty("shortProperty", Short.TYPE),
1001 new DynaProperty("stringArray", stringArray.getClass()),
1002 new DynaProperty("stringIndexed", stringArray.getClass()),
1003 new DynaProperty("stringProperty", String.class),
1004 });
1005 return (dynaClass);
1006
1007 }
1008
1009
1010 /**
1011 * Base for testGetDescriptorXxxxx() series of tests.
1012 *
1013 * @param name Name of the property to be retrieved
1014 * @param type Expected class type of this property
1015 */
1016 protected void testGetDescriptorBase(String name, Class type) {
1017
1018 try {
1019 DynaProperty descriptor =
1020 bean.getDynaClass().getDynaProperty(name);
1021 assertNotNull("Got descriptor", descriptor);
1022 assertEquals("Got correct type", type, descriptor.getType());
1023 } catch (Throwable t) {
1024 fail("Threw an exception: " + t);
1025 }
1026
1027 }
1028
1029
1030 }