1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    * 
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   * 
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */ 
17  
18  package org.apache.commons.beanutils;
19  
20  
21  import java.lang.reflect.InvocationTargetException;
22  import java.util.ArrayList;
23  import java.util.HashMap;
24  import java.util.Iterator;
25  import java.util.List;
26  import java.util.Map;
27  
28  import junit.framework.TestCase;
29  import junit.framework.Test;
30  import junit.framework.TestSuite;
31  
32  
33  /***
34   * Test case for BeanUtils when the underlying bean is actually a DynaBean.
35   *
36   * @author Craig R. McClanahan
37   * @version $Revision: 552279 $ $Date: 2007-07-01 12:04:26 +0100 (Sun, 01 Jul 2007) $
38   */
39  
40  public class DynaBeanUtilsTestCase extends TestCase {
41  
42  
43      // ----------------------------------------------------- Instance Variables
44  
45  
46      /***
47       * The basic test bean for each test.
48       */
49      protected DynaBean bean = null;
50  
51  
52      /***
53       * The nested bean pointed at by the "nested" property.
54       */
55      protected TestBean nested = null;
56  
57  
58      /***
59       * The set of properties that should be described.
60       */
61      protected String describes[] =
62      { "booleanProperty",
63        "booleanSecond",
64        "byteProperty",
65        "doubleProperty",
66        "dupProperty",
67        "floatProperty",
68        "intArray",
69        "intIndexed",
70        "intProperty",
71        "listIndexed",
72        "longProperty",
73        "mapProperty",
74        "mappedProperty",
75        "mappedIntProperty",
76        "nested",
77        "nullProperty",
78        //      "readOnlyProperty",
79        "shortProperty",
80        "stringArray",
81        "stringIndexed",
82        "stringProperty"
83      };
84  
85  
86      // ----------------------------------------------------------- Constructors
87  
88  
89      /***
90       * Construct a new instance of this test case.
91       *
92       * @param name Name of the test case
93       */
94      public DynaBeanUtilsTestCase(String name) {
95  
96          super(name);
97  
98      }
99  
100 
101     // --------------------------------------------------- Overall Test Methods
102 
103 
104     /***
105      * Set up instance variables required by this test case.
106      */
107     public void setUp() throws Exception {
108 
109         ConvertUtils.deregister();
110 
111         // Instantiate a new DynaBean instance
112         DynaClass dynaClass = createDynaClass();
113         bean = dynaClass.newInstance();
114 
115         // Initialize the DynaBean's property values (like TestBean)
116         bean.set("booleanProperty", new Boolean(true));
117         bean.set("booleanSecond", new Boolean(true));
118         bean.set("byteProperty", new Byte((byte) 121));
119         bean.set("doubleProperty", new Double(321.0));
120         bean.set("floatProperty", new Float((float) 123.0));
121         String dupProperty[] = { "Dup 0", "Dup 1", "Dup 2", "Dup 3", "Dup 4"};
122         bean.set("dupProperty", dupProperty);
123         int intArray[] = { 0, 10, 20, 30, 40 };
124         bean.set("intArray", intArray);
125         int intIndexed[] = { 0, 10, 20, 30, 40 };
126         bean.set("intIndexed", intIndexed);
127         bean.set("intProperty", new Integer(123));
128         List listIndexed = new ArrayList();
129         listIndexed.add("String 0");
130         listIndexed.add("String 1");
131         listIndexed.add("String 2");
132         listIndexed.add("String 3");
133         listIndexed.add("String 4");
134         bean.set("listIndexed", listIndexed);
135         bean.set("longProperty", new Long(321));
136         HashMap mapProperty = new HashMap();
137         mapProperty.put("First Key", "First Value");
138         mapProperty.put("Second Key", "Second Value");
139         bean.set("mapProperty", mapProperty);
140         HashMap mappedProperty = new HashMap();
141         mappedProperty.put("First Key", "First Value");
142         mappedProperty.put("Second Key", "Second Value");
143         bean.set("mappedProperty", mappedProperty);
144         HashMap mappedIntProperty = new HashMap();
145         mappedIntProperty.put("One", new Integer(1));
146         mappedIntProperty.put("Two", new Integer(2));
147         bean.set("mappedIntProperty", mappedIntProperty);
148         nested = new TestBean();
149         bean.set("nested", nested);
150         // Property "nullProperty" is not initialized, so it should return null
151         bean.set("shortProperty", new Short((short) 987));
152         String stringArray[] =
153                 { "String 0", "String 1", "String 2", "String 3", "String 4" };
154         bean.set("stringArray", stringArray);
155         String stringIndexed[] =
156                 { "String 0", "String 1", "String 2", "String 3", "String 4" };
157         bean.set("stringIndexed", stringIndexed);
158         bean.set("stringProperty", "This is a string");
159 
160     }
161 
162 
163     /***
164      * Return the tests included in this test suite.
165      */
166     public static Test suite() {
167 
168         return (new TestSuite(DynaBeanUtilsTestCase.class));
169 
170     }
171 
172 
173     /***
174      * Tear down instance variables required by this test case.
175      */
176     public void tearDown() {
177 
178         bean = null;
179         nested = null;
180 
181     }
182 
183 
184 
185     // ------------------------------------------------ Individual Test Methods
186 
187     /***
188      * Test the cloneBean() method from a DynaBean.
189      */
190     public void testCloneDynaBean() {
191 
192         // Set up an origin bean with customized properties
193         DynaClass dynaClass = DynaBeanUtilsTestCase.createDynaClass();
194         DynaBean orig = null;
195         try {
196             orig = dynaClass.newInstance();
197         } catch (Exception e) {
198             fail("newInstance(): " + e);
199         }
200         orig.set("booleanProperty", Boolean.FALSE);
201         orig.set("byteProperty", new Byte((byte)111));
202         orig.set("doubleProperty", new Double(333.33));
203         orig.set("dupProperty", new String[] { "New 0", "New 1", "New 2" });
204         orig.set("intArray", new int[] { 100, 200, 300 });
205         orig.set("intProperty", new Integer(333));
206         orig.set("longProperty", new Long(3333));
207         orig.set("shortProperty", new Short((short) 33));
208         orig.set("stringArray", new String[] { "New 0", "New 1" });
209         orig.set("stringProperty", "Custom string");
210 
211         // Copy the origin bean to our destination test bean
212         DynaBean clonedBean = null;
213         try {
214             clonedBean = (DynaBean) BeanUtils.cloneBean(orig);
215         } catch (Exception e) {
216             fail("Threw exception: " + e);
217         }
218 
219         // Validate the results for scalar properties
220         assertEquals("Cloned boolean property",
221                      false,
222                      ((Boolean) clonedBean.get("booleanProperty")).booleanValue());
223         assertEquals("Cloned byte property",
224                      (byte) 111,
225                      ((Byte) clonedBean.get("byteProperty")).byteValue());
226         assertEquals("Cloned double property",
227                      333.33,
228                      ((Double) clonedBean.get("doubleProperty")).doubleValue(),
229                      0.005);
230         assertEquals("Cloned int property",
231                      333,
232                      ((Integer) clonedBean.get("intProperty")).intValue());
233         assertEquals("Cloned long property",
234                      3333,
235                      ((Long) clonedBean.get("longProperty")).longValue());
236         assertEquals("Cloned short property",
237                      (short) 33,
238                      ((Short) clonedBean.get("shortProperty")).shortValue());
239         assertEquals("Cloned string property",
240                      "Custom string",
241                      (String) clonedBean.get("stringProperty"));
242 
243         // Validate the results for array properties
244         String dupProperty[] = (String[]) clonedBean.get("dupProperty");
245         assertNotNull("dupProperty present", dupProperty);
246         assertEquals("dupProperty length", 3, dupProperty.length);
247         assertEquals("dupProperty[0]", "New 0", dupProperty[0]);
248         assertEquals("dupProperty[1]", "New 1", dupProperty[1]);
249         assertEquals("dupProperty[2]", "New 2", dupProperty[2]);
250         int intArray[] = (int[]) clonedBean.get("intArray");
251         assertNotNull("intArray present", intArray);
252         assertEquals("intArray length", 3, intArray.length);
253         assertEquals("intArray[0]", 100, intArray[0]);
254         assertEquals("intArray[1]", 200, intArray[1]);
255         assertEquals("intArray[2]", 300, intArray[2]);
256         String stringArray[] = (String[]) clonedBean.get("stringArray");
257         assertNotNull("stringArray present", stringArray);
258         assertEquals("stringArray length", 2, stringArray.length);
259         assertEquals("stringArray[0]", "New 0", stringArray[0]);
260         assertEquals("stringArray[1]", "New 1", stringArray[1]);
261 
262     }
263 
264     /***
265      * Test the copyProperties() method from a DynaBean.
266      */
267     public void testCopyPropertiesDynaBean() {
268 
269         // Set up an origin bean with customized properties
270         DynaClass dynaClass = DynaBeanUtilsTestCase.createDynaClass();
271         DynaBean orig = null;
272         try {
273             orig = dynaClass.newInstance();
274         } catch (Exception e) {
275             fail("newInstance(): " + e);
276         }
277         orig.set("booleanProperty", Boolean.FALSE);
278         orig.set("byteProperty", new Byte((byte)111));
279         orig.set("doubleProperty", new Double(333.33));
280         orig.set("dupProperty", new String[] { "New 0", "New 1", "New 2" });
281         orig.set("intArray", new int[] { 100, 200, 300 });
282         orig.set("intProperty", new Integer(333));
283         orig.set("longProperty", new Long(3333));
284         orig.set("shortProperty", new Short((short) 33));
285         orig.set("stringArray", new String[] { "New 0", "New 1" });
286         orig.set("stringProperty", "Custom string");
287 
288         // Copy the origin bean to our destination test bean
289         try {
290             BeanUtils.copyProperties(bean, orig);
291         } catch (Exception e) {
292             fail("Threw exception: " + e);
293         }
294 
295         // Validate the results for scalar properties
296         assertEquals("Copied boolean property",
297                      false,
298                      ((Boolean) bean.get("booleanProperty")).booleanValue());
299         assertEquals("Copied byte property",
300                      (byte) 111,
301                      ((Byte) bean.get("byteProperty")).byteValue());
302         assertEquals("Copied double property",
303                      333.33,
304                      ((Double) bean.get("doubleProperty")).doubleValue(),
305                      0.005);
306         assertEquals("Copied int property",
307                      333,
308                      ((Integer) bean.get("intProperty")).intValue());
309         assertEquals("Copied long property",
310                      3333,
311                      ((Long) bean.get("longProperty")).longValue());
312         assertEquals("Copied short property",
313                      (short) 33,
314                      ((Short) bean.get("shortProperty")).shortValue());
315         assertEquals("Copied string property",
316                      "Custom string",
317                      (String) bean.get("stringProperty"));
318 
319         // Validate the results for array properties
320         String dupProperty[] = (String[]) bean.get("dupProperty");
321         assertNotNull("dupProperty present", dupProperty);
322         assertEquals("dupProperty length", 3, dupProperty.length);
323         assertEquals("dupProperty[0]", "New 0", dupProperty[0]);
324         assertEquals("dupProperty[1]", "New 1", dupProperty[1]);
325         assertEquals("dupProperty[2]", "New 2", dupProperty[2]);
326         int intArray[] = (int[]) bean.get("intArray");
327         assertNotNull("intArray present", intArray);
328         assertEquals("intArray length", 3, intArray.length);
329         assertEquals("intArray[0]", 100, intArray[0]);
330         assertEquals("intArray[1]", 200, intArray[1]);
331         assertEquals("intArray[2]", 300, intArray[2]);
332         String stringArray[] = (String[]) bean.get("stringArray");
333         assertNotNull("stringArray present", stringArray);
334         assertEquals("stringArray length", 2, stringArray.length);
335         assertEquals("stringArray[0]", "New 0", stringArray[0]);
336         assertEquals("stringArray[1]", "New 1", stringArray[1]);
337 
338     }
339 
340 
341     /***
342      * Test copyProperties() when the origin is a a <code>Map</code>.
343      */
344     public void testCopyPropertiesMap() {
345 
346         Map map = new HashMap();
347         map.put("booleanProperty", "false");
348         map.put("byteProperty", "111");
349         map.put("doubleProperty", "333.0");
350         map.put("dupProperty", new String[] { "New 0", "New 1", "New 2" });
351         map.put("floatProperty", "222.0");
352         map.put("intArray", new String[] { "0", "100", "200" });
353         map.put("intProperty", "111");
354         map.put("longProperty", "444");
355         map.put("shortProperty", "555");
356         map.put("stringProperty", "New String Property");
357 
358         try {
359             BeanUtils.copyProperties(bean, map);
360         } catch (Throwable t) {
361             fail("Threw " + t.toString());
362         }
363 
364         // Scalar properties
365         assertEquals("booleanProperty", false,
366                      ((Boolean) bean.get("booleanProperty")).booleanValue());
367         assertEquals("byteProperty", (byte) 111,
368                      ((Byte) bean.get("byteProperty")).byteValue());
369         assertEquals("doubleProperty", 333.0,
370                      ((Double) bean.get("doubleProperty")).doubleValue(),
371                      0.005);
372         assertEquals("floatProperty", (float) 222.0,
373                      ((Float) bean.get("floatProperty")).floatValue(),
374                      (float) 0.005);
375         assertEquals("intProperty", 111,
376                      ((Integer) bean.get("intProperty")).intValue());
377         assertEquals("longProperty", 444,
378                      ((Long) bean.get("longProperty")).longValue());
379         assertEquals("shortProperty", (short) 555,
380                      ((Short) bean.get("shortProperty")).shortValue());
381         assertEquals("stringProperty", "New String Property",
382                      (String) bean.get("stringProperty"));
383 
384         // Indexed Properties
385         String dupProperty[] = (String[]) bean.get("dupProperty");
386         assertNotNull("dupProperty present", dupProperty);
387         assertEquals("dupProperty length", 3, dupProperty.length);
388         assertEquals("dupProperty[0]", "New 0", dupProperty[0]);
389         assertEquals("dupProperty[1]", "New 1", dupProperty[1]);
390         assertEquals("dupProperty[2]", "New 2", dupProperty[2]);
391         int intArray[] = (int[]) bean.get("intArray");
392         assertNotNull("intArray present", intArray);
393         assertEquals("intArray length", 3, intArray.length);
394         assertEquals("intArray[0]", 0, intArray[0]);
395         assertEquals("intArray[1]", 100, intArray[1]);
396         assertEquals("intArray[2]", 200, intArray[2]);
397 
398     }
399 
400 
401     /***
402      * Test the copyProperties() method from a standard JavaBean.
403      */
404     public void testCopyPropertiesStandard() {
405 
406         // Set up an origin bean with customized properties
407         TestBean orig = new TestBean();
408         orig.setBooleanProperty(false);
409         orig.setByteProperty((byte) 111);
410         orig.setDoubleProperty(333.33);
411         orig.setDupProperty(new String[] { "New 0", "New 1", "New 2" });
412         orig.setIntArray(new int[] { 100, 200, 300 });
413         orig.setIntProperty(333);
414         orig.setLongProperty(3333);
415         orig.setShortProperty((short) 33);
416         orig.setStringArray(new String[] { "New 0", "New 1" });
417         orig.setStringProperty("Custom string");
418 
419         // Copy the origin bean to our destination test bean
420         try {
421             BeanUtils.copyProperties(bean, orig);
422         } catch (Exception e) {
423             fail("Threw exception: " + e);
424         }
425 
426         // Validate the results for scalar properties
427         assertEquals("Copied boolean property",
428                      false,
429                      ((Boolean) bean.get("booleanProperty")).booleanValue());
430         assertEquals("Copied byte property",
431                      (byte) 111,
432                      ((Byte) bean.get("byteProperty")).byteValue());
433         assertEquals("Copied double property",
434                      333.33,
435                      ((Double) bean.get("doubleProperty")).doubleValue(),
436                      0.005);
437         assertEquals("Copied int property",
438                      333,
439                      ((Integer) bean.get("intProperty")).intValue());
440         assertEquals("Copied long property",
441                      3333,
442                      ((Long) bean.get("longProperty")).longValue());
443         assertEquals("Copied short property",
444                      (short) 33,
445                      ((Short) bean.get("shortProperty")).shortValue());
446         assertEquals("Copied string property",
447                      "Custom string",
448                      (String) bean.get("stringProperty"));
449 
450         // Validate the results for array properties
451         String dupProperty[] = (String[]) bean.get("dupProperty");
452         assertNotNull("dupProperty present", dupProperty);
453         assertEquals("dupProperty length", 3, dupProperty.length);
454         assertEquals("dupProperty[0]", "New 0", dupProperty[0]);
455         assertEquals("dupProperty[1]", "New 1", dupProperty[1]);
456         assertEquals("dupProperty[2]", "New 2", dupProperty[2]);
457         int intArray[] = (int[]) bean.get("intArray");
458         assertNotNull("intArray present", intArray);
459         assertEquals("intArray length", 3, intArray.length);
460         assertEquals("intArray[0]", 100, intArray[0]);
461         assertEquals("intArray[1]", 200, intArray[1]);
462         assertEquals("intArray[2]", 300, intArray[2]);
463         String stringArray[] = (String[]) bean.get("stringArray");
464         assertNotNull("stringArray present", stringArray);
465         assertEquals("stringArray length", 2, stringArray.length);
466         assertEquals("stringArray[0]", "New 0", stringArray[0]);
467         assertEquals("stringArray[1]", "New 1", stringArray[1]);
468 
469     }
470 
471 
472     /***
473      * Test the describe() method.
474      */
475     public void testDescribe() {
476 
477         Map map = null;
478         try {
479             map = PropertyUtils.describe(bean);
480         } catch (Exception e) {
481             fail("Threw exception " + e);
482         }
483 
484         // Verify existence of all the properties that should be present
485         for (int i = 0; i < describes.length; i++) {
486             assertTrue("Property '" + describes[i] + "' is present",
487                        map.containsKey(describes[i]));
488         }
489         assertTrue("Property 'writeOnlyProperty' is not present",
490                    !map.containsKey("writeOnlyProperty"));
491 
492         // Verify the values of scalar properties
493         assertEquals("Value of 'booleanProperty'",
494                      Boolean.TRUE,
495                      map.get("booleanProperty"));
496         assertEquals("Value of 'byteProperty'",
497                      new Byte((byte) 121),
498                      map.get("byteProperty"));
499         assertEquals("Value of 'doubleProperty'",
500                      new Double(321.0),
501                      map.get("doubleProperty"));
502         assertEquals("Value of 'floatProperty'",
503                      new Float((float) 123.0),
504                      map.get("floatProperty"));
505         assertEquals("Value of 'intProperty'",
506                      new Integer(123),
507                      map.get("intProperty"));
508         assertEquals("Value of 'longProperty'",
509                      new Long(321),
510                      map.get("longProperty"));
511         assertEquals("Value of 'shortProperty'",
512                      new Short((short) 987),
513                      map.get("shortProperty"));
514         assertEquals("Value of 'stringProperty'",
515                      "This is a string",
516                      (String) map.get("stringProperty"));
517 
518     }
519 
520 
521     /***
522      * Test populate() method on array properties as a whole.
523      */
524     public void testPopulateArrayProperties() {
525 
526         try {
527 
528             HashMap map = new HashMap();
529             //            int intArray[] = new int[] { 123, 456, 789 };
530             String intArrayIn[] = new String[] { "123", "456", "789" };
531             map.put("intArray", intArrayIn);
532             String stringArray[] = new String[]
533                 { "New String 0", "New String 1" };
534             map.put("stringArray", stringArray);
535 
536             BeanUtils.populate(bean, map);
537 
538             int intArray[] = (int[]) bean.get("intArray");
539             assertNotNull("intArray is present", intArray);
540             assertEquals("intArray length",
541                          3, intArray.length);
542             assertEquals("intArray[0]", 123, intArray[0]);
543             assertEquals("intArray[1]", 456, intArray[1]);
544             assertEquals("intArray[2]", 789, intArray[2]);
545             stringArray = (String[]) bean.get("stringArray");
546             assertNotNull("stringArray is present", stringArray);
547             assertEquals("stringArray length", 2, stringArray.length);
548             assertEquals("stringArray[0]", "New String 0", stringArray[0]);
549             assertEquals("stringArray[1]", "New String 1", stringArray[1]);
550 
551         } catch (IllegalAccessException e) {
552             fail("IllegalAccessException");
553         } catch (InvocationTargetException e) {
554             fail("InvocationTargetException");
555         }
556 
557     }
558 
559 
560     /***
561      *  tests the string and int arrays of TestBean
562      */
563     public void testGetArrayProperty() {
564         try {
565             String arr[] = BeanUtils.getArrayProperty(bean, "stringArray");
566             String comp[] = (String[]) bean.get("stringArray");
567 
568             assertTrue("String array length = " + comp.length,
569                     (comp.length == arr.length));
570 
571             arr = BeanUtils.getArrayProperty(bean, "intArray");
572             int iarr[] = (int[]) bean.get("intArray");
573 
574             assertTrue("String array length = " + iarr.length,
575                     (iarr.length == arr.length));
576         } catch (IllegalAccessException e) {
577             fail("IllegalAccessException");
578         } catch (InvocationTargetException e) {
579             fail("InvocationTargetException");
580         } catch (NoSuchMethodException e) {
581             fail("NoSuchMethodException");
582         }
583 
584     }
585 
586 
587     /***
588      *  tests getting an indexed property
589      */
590     public void testGetIndexedProperty1() {
591         try {
592             String val = BeanUtils.getIndexedProperty(bean, "intIndexed[3]");
593             String comp = String.valueOf(bean.get("intIndexed", 3));
594             assertTrue("intIndexed[3] == " + comp, val.equals(comp));
595 
596             val = BeanUtils.getIndexedProperty(bean, "stringIndexed[3]");
597             comp = (String) bean.get("stringIndexed", 3);
598             assertTrue("stringIndexed[3] == " + comp, val.equals(comp));
599         } catch (IllegalAccessException e) {
600             fail("IllegalAccessException");
601         } catch (InvocationTargetException e) {
602             fail("InvocationTargetException");
603         } catch (NoSuchMethodException e) {
604             fail("NoSuchMethodException");
605         }
606     }
607 
608 
609     /***
610      *  tests getting an indexed property
611      */
612     public void testGetIndexedProperty2() {
613         try {
614             String val = BeanUtils.getIndexedProperty(bean, "intIndexed", 3);
615             String comp = String.valueOf(bean.get("intIndexed", 3));
616 
617             assertTrue("intIndexed,3 == " + comp, val.equals(comp));
618 
619             val = BeanUtils.getIndexedProperty(bean, "stringIndexed", 3);
620             comp = (String) bean.get("stringIndexed", 3);
621 
622             assertTrue("stringIndexed,3 == " + comp, val.equals(comp));
623 
624         } catch (IllegalAccessException e) {
625             fail("IllegalAccessException");
626         } catch (InvocationTargetException e) {
627             fail("InvocationTargetException");
628         } catch (NoSuchMethodException e) {
629             fail("NoSuchMethodException");
630         }
631     }
632 
633 
634     /***
635      *  tests getting a nested property
636      */
637     public void testGetNestedProperty() {
638         try {
639             String val = BeanUtils.getNestedProperty(bean, "nested.stringProperty");
640             String comp = nested.getStringProperty();
641             assertTrue("nested.StringProperty == " + comp,
642                     val.equals(comp));
643         } catch (IllegalAccessException e) {
644             fail("IllegalAccessException");
645         } catch (InvocationTargetException e) {
646             fail("InvocationTargetException");
647         } catch (NoSuchMethodException e) {
648             fail("NoSuchMethodException");
649         }
650     }
651 
652 
653     /***
654      *  tests getting a 'whatever' property
655      */
656     public void testGetGeneralProperty() {
657         try {
658             String val = BeanUtils.getProperty(bean, "nested.intIndexed[2]");
659             String comp = String.valueOf(bean.get("intIndexed", 2));
660 
661             assertTrue("nested.intIndexed[2] == " + comp,
662                     val.equals(comp));
663         } catch (IllegalAccessException e) {
664             fail("IllegalAccessException");
665         } catch (InvocationTargetException e) {
666             fail("InvocationTargetException");
667         } catch (NoSuchMethodException e) {
668             fail("NoSuchMethodException");
669         }
670     }
671 
672 
673     /***
674      *  tests getting a 'whatever' property
675      */
676     public void testGetSimpleProperty() {
677         try {
678             String val = BeanUtils.getSimpleProperty(bean, "shortProperty");
679             String comp = String.valueOf(bean.get("shortProperty"));
680 
681             assertTrue("shortProperty == " + comp,
682                     val.equals(comp));
683         } catch (IllegalAccessException e) {
684             fail("IllegalAccessException");
685         } catch (InvocationTargetException e) {
686             fail("InvocationTargetException");
687         } catch (NoSuchMethodException e) {
688             fail("NoSuchMethodException");
689         }
690     }
691 
692 
693     /***
694      * Test populate() method on individual array elements.
695      */
696     public void testPopulateArrayElements() {
697 
698         try {
699 
700             HashMap map = new HashMap();
701             map.put("intIndexed[0]", "100");
702             map.put("intIndexed[2]", "120");
703             map.put("intIndexed[4]", "140");
704 
705             BeanUtils.populate(bean, map);
706             Integer intIndexed0 = (Integer) bean.get("intIndexed", 0);
707             assertEquals("intIndexed[0] is 100",
708                          100, intIndexed0.intValue());
709             Integer intIndexed1 = (Integer) bean.get("intIndexed", 1);
710             assertEquals("intIndexed[1] is 10",
711                          10, intIndexed1.intValue());
712             Integer intIndexed2 = (Integer) bean.get("intIndexed", 2);
713             assertEquals("intIndexed[2] is 120",
714                          120, intIndexed2.intValue());
715             Integer intIndexed3 = (Integer) bean.get("intIndexed", 3);
716             assertEquals("intIndexed[3] is 30",
717                          30, intIndexed3.intValue());
718             Integer intIndexed4 = (Integer) bean.get("intIndexed", 4);
719             assertEquals("intIndexed[4] is 140",
720                          140, intIndexed4.intValue());
721 
722             map.clear();
723             map.put("stringIndexed[1]", "New String 1");
724             map.put("stringIndexed[3]", "New String 3");
725 
726             BeanUtils.populate(bean, map);
727 
728             assertEquals("stringIndexed[0] is \"String 0\"",
729                          "String 0",
730                          (String) bean.get("stringIndexed", 0));
731             assertEquals("stringIndexed[1] is \"New String 1\"",
732                          "New String 1",
733                          (String) bean.get("stringIndexed", 1));
734             assertEquals("stringIndexed[2] is \"String 2\"",
735                          "String 2",
736                          (String) bean.get("stringIndexed", 2));
737             assertEquals("stringIndexed[3] is \"New String 3\"",
738                          "New String 3",
739                          (String) bean.get("stringIndexed", 3));
740             assertEquals("stringIndexed[4] is \"String 4\"",
741                          "String 4",
742                          (String) bean.get("stringIndexed", 4));
743 
744         } catch (IllegalAccessException e) {
745             fail("IllegalAccessException");
746         } catch (InvocationTargetException e) {
747             fail("InvocationTargetException");
748         }
749 
750     }
751 
752 
753     /***
754      * Test populate() on mapped properties.
755      */
756     public void testPopulateMapped() {
757 
758         try {
759 
760             HashMap map = new HashMap();
761             map.put("mappedProperty(First Key)", "New First Value");
762             map.put("mappedProperty(Third Key)", "New Third Value");
763 
764             BeanUtils.populate(bean, map);
765 
766             assertEquals("mappedProperty(First Key)",
767                          "New First Value",
768                          (String) bean.get("mappedProperty", "First Key"));
769             assertEquals("mappedProperty(Second Key)",
770                          "Second Value",
771                          (String) bean.get("mappedProperty", "Second Key"));
772             assertEquals("mappedProperty(Third Key)",
773                          "New Third Value",
774                          (String) bean.get("mappedProperty", "Third Key"));
775             assertNull("mappedProperty(Fourth Key",
776                        bean.get("mappedProperty", "Fourth Key"));
777 
778         } catch (IllegalAccessException e) {
779             fail("IllegalAccessException");
780         } catch (InvocationTargetException e) {
781             fail("InvocationTargetException");
782         }
783 
784     }
785 
786 
787     /***
788      * Test populate() method on nested properties.
789      */
790     public void testPopulateNested() {
791 
792         try {
793 
794             HashMap map = new HashMap();
795             map.put("nested.booleanProperty", "false");
796             // booleanSecond is left at true
797             map.put("nested.doubleProperty", "432.0");
798             // floatProperty is left at 123.0
799             map.put("nested.intProperty", "543");
800             // longProperty is left at 321
801             map.put("nested.shortProperty", "654");
802             // stringProperty is left at "This is a string"
803 
804             BeanUtils.populate(bean, map);
805 
806             TestBean nested = (TestBean) bean.get("nested");
807             assertTrue("booleanProperty is false",
808                        !nested.getBooleanProperty());
809             assertTrue("booleanSecond is true",
810                        nested.isBooleanSecond());
811             assertEquals("doubleProperty is 432.0",
812                          432.0,
813                          nested.getDoubleProperty(),
814                          0.005);
815             assertEquals("floatProperty is 123.0",
816                          (float) 123.0,
817                          nested.getFloatProperty(),
818                          (float) 0.005);
819             assertEquals("intProperty is 543",
820                          543, nested.getIntProperty());
821             assertEquals("longProperty is 321",
822                          321, nested.getLongProperty());
823             assertEquals("shortProperty is 654",
824                          (short) 654, nested.getShortProperty());
825             assertEquals("stringProperty is \"This is a string\"",
826                          "This is a string",
827                          nested.getStringProperty());
828 
829         } catch (IllegalAccessException e) {
830             fail("IllegalAccessException");
831         } catch (InvocationTargetException e) {
832             fail("InvocationTargetException");
833         }
834 
835     }
836 
837 
838     /***
839      * Test populate() method on scalar properties.
840      */
841     public void testPopulateScalar() {
842 
843         try {
844 
845             bean.set("nullProperty", "non-null value");
846 
847             HashMap map = new HashMap();
848             map.put("booleanProperty", "false");
849             // booleanSecond is left at true
850             map.put("doubleProperty", "432.0");
851             // floatProperty is left at 123.0
852             map.put("intProperty", "543");
853             // longProperty is left at 321
854             map.put("nullProperty", null);
855             map.put("shortProperty", "654");
856             // stringProperty is left at "This is a string"
857 
858             BeanUtils.populate(bean, map);
859 
860             Boolean booleanProperty = (Boolean) bean.get("booleanProperty");
861             assertTrue("booleanProperty is false", !booleanProperty.booleanValue());
862             Boolean booleanSecond = (Boolean) bean.get("booleanSecond");
863             assertTrue("booleanSecond is true", booleanSecond.booleanValue());
864             Double doubleProperty = (Double) bean.get("doubleProperty");
865             assertEquals("doubleProperty is 432.0",
866                          432.0, doubleProperty.doubleValue(), 0.005);
867             Float floatProperty = (Float) bean.get("floatProperty");
868             assertEquals("floatProperty is 123.0",
869                          (float) 123.0, floatProperty.floatValue(),
870                          (float) 0.005);
871             Integer intProperty = (Integer) bean.get("intProperty");
872             assertEquals("intProperty is 543",
873                          543, intProperty.intValue());
874             Long longProperty = (Long) bean.get("longProperty");
875             assertEquals("longProperty is 321",
876                          321, longProperty.longValue());
877             assertNull("nullProperty is null", bean.get("nullProperty"));
878             Short shortProperty = (Short) bean.get("shortProperty");
879             assertEquals("shortProperty is 654",
880                          (short) 654, shortProperty.shortValue());
881             assertEquals("stringProperty is \"This is a string\"",
882                          "This is a string",
883                          (String) bean.get("stringProperty"));
884 
885         } catch (IllegalAccessException e) {
886             fail("IllegalAccessException");
887         } catch (InvocationTargetException e) {
888             fail("InvocationTargetException");
889         }
890 
891     }
892 
893 
894     /***
895      * Test calling setProperty() with null property values.
896      */
897     public void testSetPropertyNullValues() throws Exception {
898 
899         Object oldValue = null;
900         Object newValue = null;
901 
902         // Scalar value into array
903         oldValue = PropertyUtils.getSimpleProperty(bean, "stringArray");
904         BeanUtils.setProperty(bean, "stringArray", (String) null);
905         newValue = PropertyUtils.getSimpleProperty(bean, "stringArray");
906         assertNotNull("stringArray is not null", newValue);
907         assertTrue("stringArray of correct type",
908                    newValue instanceof String[]);
909         assertEquals("stringArray length",
910                      1, ((String[]) newValue).length);
911         PropertyUtils.setProperty(bean, "stringArray", oldValue);
912 
913         // Indexed value into array
914         oldValue = PropertyUtils.getSimpleProperty(bean, "stringArray");
915         BeanUtils.setProperty(bean, "stringArray[2]", (String) null);
916         newValue = PropertyUtils.getSimpleProperty(bean, "stringArray");
917         assertNotNull("stringArray is not null", newValue);
918         assertTrue("stringArray of correct type",
919                    newValue instanceof String[]);
920         assertEquals("stringArray length",
921                      5, ((String[]) newValue).length);
922         assertTrue("stringArray[2] is null",
923                    ((String[]) newValue)[2] == null);
924         PropertyUtils.setProperty(bean, "stringArray", oldValue);
925 
926         // Value into scalar
927         BeanUtils.setProperty(bean, "stringProperty", null);
928         assertTrue("stringProperty is now null",
929                    BeanUtils.getProperty(bean, "stringProperty") == null);
930 
931     }
932 
933 
934     /***
935      * Test converting to and from primitive wrapper types.
936      */
937     public void testSetPropertyOnPrimitiveWrappers() throws Exception {
938 
939         BeanUtils.setProperty(bean,"intProperty", new Integer(1));
940         assertEquals(1,((Integer) bean.get("intProperty")).intValue());
941         BeanUtils.setProperty(bean,"stringProperty", new Integer(1));
942         assertEquals(1, Integer.parseInt((String) bean.get("stringProperty")));
943 
944     }
945 
946 
947     /***
948      * Test setting a null property value.
949      */
950     public void testSetPropertyNull() throws Exception {
951 
952         bean.set("nullProperty", "non-null value");
953         BeanUtils.setProperty(bean, "nullProperty", null);
954         assertNull("nullProperty is null", bean.get("nullProperty"));
955 
956     }
957 
958 
959     /***
960      * Test narrowing and widening conversions on byte.
961      */
962     public void testCopyPropertyByte() throws Exception {
963 
964         BeanUtils.setProperty(bean, "byteProperty", new Byte((byte) 123));
965         assertEquals((byte) 123, ((Byte) bean.get("byteProperty")).byteValue());
966 /*
967         BeanUtils.setProperty(bean, "byteProperty", new Double((double) 123));
968         assertEquals((byte) 123, ((Byte) bean.get("byteProperty")).byteValue());
969         BeanUtils.setProperty(bean, "byteProperty", new Float((float) 123));
970         assertEquals((byte) 123, ((Byte) bean.get("byteProperty")).byteValue());
971 */
972         BeanUtils.setProperty(bean, "byteProperty", new Integer(123));
973         assertEquals((byte) 123, ((Byte) bean.get("byteProperty")).byteValue());
974         BeanUtils.setProperty(bean, "byteProperty", new Long(123));
975         assertEquals((byte) 123, ((Byte) bean.get("byteProperty")).byteValue());
976         BeanUtils.setProperty(bean, "byteProperty", new Short((short) 123));
977         assertEquals((byte) 123, ((Byte) bean.get("byteProperty")).byteValue());
978 
979     }
980 
981 
982     /***
983      * Test narrowing and widening conversions on double.
984      */
985     public void testCopyPropertyDouble() throws Exception {
986 
987         BeanUtils.setProperty(bean, "doubleProperty", new Byte((byte) 123));
988         assertEquals(123, ((Double) bean.get("doubleProperty")).doubleValue(), 0.005);
989         BeanUtils.setProperty(bean, "doubleProperty", new Double(123));
990         assertEquals(123, ((Double) bean.get("doubleProperty")).doubleValue(), 0.005);
991         BeanUtils.setProperty(bean, "doubleProperty", new Float(123));
992         assertEquals(123, ((Double) bean.get("doubleProperty")).doubleValue(), 0.005);
993         BeanUtils.setProperty(bean, "doubleProperty", new Integer(123));
994         assertEquals(123, ((Double) bean.get("doubleProperty")).doubleValue(), 0.005);
995         BeanUtils.setProperty(bean, "doubleProperty", new Long(123));
996         assertEquals(123, ((Double) bean.get("doubleProperty")).doubleValue(), 0.005);
997         BeanUtils.setProperty(bean, "doubleProperty", new Short((short) 123));
998         assertEquals(123, ((Double) bean.get("doubleProperty")).doubleValue(), 0.005);
999 
1000     }
1001 
1002 
1003     /***
1004      * Test narrowing and widening conversions on float.
1005      */
1006     public void testCopyPropertyFloat() throws Exception {
1007 
1008         BeanUtils.setProperty(bean, "floatProperty", new Byte((byte) 123));
1009         assertEquals(123, ((Float) bean.get("floatProperty")).floatValue(), 0.005);
1010         BeanUtils.setProperty(bean, "floatProperty", new Double(123));
1011         assertEquals(123, ((Float) bean.get("floatProperty")).floatValue(), 0.005);
1012         BeanUtils.setProperty(bean, "floatProperty", new Float(123));
1013         assertEquals(123, ((Float) bean.get("floatProperty")).floatValue(), 0.005);
1014         BeanUtils.setProperty(bean, "floatProperty", new Integer(123));
1015         assertEquals(123, ((Float) bean.get("floatProperty")).floatValue(), 0.005);
1016         BeanUtils.setProperty(bean, "floatProperty", new Long(123));
1017         assertEquals(123, ((Float) bean.get("floatProperty")).floatValue(), 0.005);
1018         BeanUtils.setProperty(bean, "floatProperty", new Short((short) 123));
1019         assertEquals(123, ((Float) bean.get("floatProperty")).floatValue(), 0.005);
1020 
1021     }
1022 
1023 
1024     /***
1025      * Test narrowing and widening conversions on int.
1026      */
1027     public void testCopyPropertyInteger() throws Exception {
1028 
1029         BeanUtils.setProperty(bean, "longProperty", new Byte((byte) 123));
1030         assertEquals(123, ((Integer) bean.get("intProperty")).intValue());
1031 /*
1032         BeanUtils.setProperty(bean, "longProperty", new Double((double) 123));
1033         assertEquals((int) 123, ((Integer) bean.get("intProperty")).intValue());
1034         BeanUtils.setProperty(bean, "longProperty", new Float((float) 123));
1035         assertEquals((int) 123, ((Integer) bean.get("intProperty")).intValue());
1036 */
1037         BeanUtils.setProperty(bean, "longProperty", new Integer(123));
1038         assertEquals(123, ((Integer) bean.get("intProperty")).intValue());
1039         BeanUtils.setProperty(bean, "longProperty", new Long(123));
1040         assertEquals(123, ((Integer) bean.get("intProperty")).intValue());
1041         BeanUtils.setProperty(bean, "longProperty", new Short((short) 123));
1042         assertEquals(123, ((Integer) bean.get("intProperty")).intValue());
1043 
1044     }
1045 
1046 
1047     /***
1048      * Test narrowing and widening conversions on long.
1049      */
1050     public void testCopyPropertyLong() throws Exception {
1051 
1052         BeanUtils.setProperty(bean, "longProperty", new Byte((byte) 123));
1053         assertEquals(123, ((Long) bean.get("longProperty")).longValue());
1054 /*
1055         BeanUtils.setProperty(bean, "longProperty", new Double((double) 123));
1056         assertEquals((long) 123, ((Long) bean.get("longProperty")).longValue());
1057         BeanUtils.setProperty(bean, "longProperty", new Float((float) 123));
1058         assertEquals((long) 123, ((Long) bean.get("longProperty")).longValue());
1059 */
1060         BeanUtils.setProperty(bean, "longProperty", new Integer(123));
1061         assertEquals(123, ((Long) bean.get("longProperty")).longValue());
1062         BeanUtils.setProperty(bean, "longProperty", new Long(123));
1063         assertEquals(123, ((Long) bean.get("longProperty")).longValue());
1064         BeanUtils.setProperty(bean, "longProperty", new Short((short) 123));
1065         assertEquals(123, ((Long) bean.get("longProperty")).longValue());
1066 
1067     }
1068 
1069 
1070     /***
1071      * Test copying a null property value.
1072      */
1073     public void testCopyPropertyNull() throws Exception {
1074 
1075         bean.set("nullProperty", "non-null value");
1076         BeanUtils.copyProperty(bean, "nullProperty", null);
1077         assertNull("nullProperty is null", bean.get("nullProperty"));
1078 
1079     }
1080 
1081 
1082     /***
1083      * Test narrowing and widening conversions on short.
1084      */
1085     public void testCopyPropertyShort() throws Exception {
1086 
1087         BeanUtils.setProperty(bean, "shortProperty", new Byte((byte) 123));
1088         assertEquals((short) 123, ((Short) bean.get("shortProperty")).shortValue());
1089 /*
1090         BeanUtils.setProperty(bean, "shortProperty", new Double((double) 123));
1091         assertEquals((short) 123, ((Short) bean.get("shortProperty")).shortValue());
1092         BeanUtils.setProperty(bean, "shortProperty", new Float((float) 123));
1093         assertEquals((short) 123, ((Short) bean.get("shortProperty")).shortValue());
1094 */
1095         BeanUtils.setProperty(bean, "shortProperty", new Integer(123));
1096         assertEquals((short) 123, ((Short) bean.get("shortProperty")).shortValue());
1097         BeanUtils.setProperty(bean, "shortProperty", new Long(123));
1098         assertEquals((short) 123, ((Short) bean.get("shortProperty")).shortValue());
1099         BeanUtils.setProperty(bean, "shortProperty", new Short((short) 123));
1100         assertEquals((short) 123, ((Short) bean.get("shortProperty")).shortValue());
1101 
1102     }
1103 
1104 
1105     /***
1106      * Test copying a property using a nested indexed array expression,
1107      * with and without conversions.
1108      */
1109     public void testCopyPropertyNestedIndexedArray() throws Exception {
1110 
1111         int origArray[] = { 0, 10, 20, 30, 40};
1112         int intArray[] = { 0, 0, 0 };
1113         ((TestBean) bean.get("nested")).setIntArray(intArray);
1114         int intChanged[] = { 0, 0, 0 };
1115 
1116         // No conversion required
1117         BeanUtils.copyProperty(bean, "nested.intArray[1]", new Integer(1));
1118         checkIntArray((int[]) bean.get("intArray"), origArray);
1119         intChanged[1] = 1;
1120         checkIntArray(((TestBean) bean.get("nested")).getIntArray(),
1121                       intChanged);
1122 
1123         // Widening conversion required
1124         BeanUtils.copyProperty(bean, "nested.intArray[1]", new Byte((byte) 2));
1125         checkIntArray((int[]) bean.get("intArray"), origArray);
1126         intChanged[1] = 2;
1127         checkIntArray(((TestBean) bean.get("nested")).getIntArray(),
1128                       intChanged);
1129 
1130         // Narrowing conversion required
1131         BeanUtils.copyProperty(bean, "nested.intArray[1]", new Long(3));
1132         checkIntArray((int[]) bean.get("intArray"), origArray);
1133         intChanged[1] = 3;
1134         checkIntArray(((TestBean) bean.get("nested")).getIntArray(),
1135                       intChanged);
1136 
1137         // String conversion required
1138         BeanUtils.copyProperty(bean, "nested.intArray[1]", "4");
1139         checkIntArray((int[]) bean.get("intArray"), origArray);
1140         intChanged[1] = 4;
1141         checkIntArray(((TestBean) bean.get("nested")).getIntArray(),
1142                       intChanged);
1143 
1144     }
1145 
1146 
1147     /***
1148      * Test copying a property using a nested mapped map property.
1149      */
1150     public void testCopyPropertyNestedMappedMap() throws Exception {
1151 
1152         Map origMap = new HashMap();
1153         origMap.put("First Key", "First Value");
1154         origMap.put("Second Key", "Second Value");
1155         Map changedMap = new HashMap();
1156         changedMap.put("First Key", "First Value");
1157         changedMap.put("Second Key", "Second Value");
1158 
1159         // No conversion required
1160         BeanUtils.copyProperty(bean, "nested.mapProperty(Second Key)",
1161                                "New Second Value");
1162         checkMap((Map) bean.get("mapProperty"), origMap);
1163         changedMap.put("Second Key", "New Second Value");
1164         checkMap(((TestBean) bean.get("nested")).getMapProperty(), changedMap);
1165 
1166     }
1167 
1168 
1169     /***
1170      * Test copying a property using a nested simple expression, with and
1171      * without conversions.
1172      */
1173     public void testCopyPropertyNestedSimple() throws Exception {
1174 
1175         bean.set("intProperty", new Integer(0));
1176         nested.setIntProperty(0);
1177 
1178         // No conversion required
1179         BeanUtils.copyProperty(bean, "nested.intProperty", new Integer(1));
1180         assertEquals(0, ((Integer) bean.get("intProperty")).intValue());
1181         assertEquals(1, nested.getIntProperty());
1182 
1183         // Widening conversion required
1184         BeanUtils.copyProperty(bean, "nested.intProperty", new Byte((byte) 2));
1185         assertEquals(0, ((Integer) bean.get("intProperty")).intValue());
1186         assertEquals(2, nested.getIntProperty());
1187 
1188         // Narrowing conversion required
1189         BeanUtils.copyProperty(bean, "nested.intProperty", new Long(3));
1190         assertEquals(0, ((Integer) bean.get("intProperty")).intValue());
1191         assertEquals(3, nested.getIntProperty());
1192 
1193         // String conversion required
1194         BeanUtils.copyProperty(bean, "nested.intProperty", "4");
1195         assertEquals(0, ((Integer) bean.get("intProperty")).intValue());
1196         assertEquals(4, nested.getIntProperty());
1197 
1198     }
1199 
1200 
1201     // ------------------------------------------------------ Protected Methods
1202 
1203 
1204     // Ensure that the nested intArray matches the specified values
1205     protected void checkIntArray(int actual[], int expected[]) {
1206         assertNotNull("actual array not null", actual);
1207         assertEquals("actual array length", expected.length, actual.length);
1208         for (int i = 0; i < actual.length; i++) {
1209             assertEquals("actual array value[" + i + "]",
1210                          expected[i], actual[i]);
1211         }
1212     }
1213 
1214 
1215     // Ensure that the actual Map matches the expected Map
1216     protected void checkMap(Map actual, Map expected) {
1217         assertNotNull("actual map not null", actual);
1218         assertEquals("actual map size", expected.size(), actual.size());
1219         Iterator keys = expected.keySet().iterator();
1220         while (keys.hasNext()) {
1221             Object key = keys.next();
1222             assertEquals("actual map value(" + key + ")",
1223                          expected.get(key), actual.get(key));
1224         }
1225     }
1226 
1227 
1228     /***
1229      * Create and return a <code>DynaClass</code> instance for our test
1230      * <code>DynaBean</code>.
1231      */
1232     protected static DynaClass createDynaClass() {
1233 
1234         int intArray[] = new int[0];
1235         String stringArray[] = new String[0];
1236 
1237         DynaClass dynaClass = new BasicDynaClass
1238                 ("TestDynaClass", null,
1239                         new DynaProperty[]{
1240                             new DynaProperty("booleanProperty", Boolean.TYPE),
1241                             new DynaProperty("booleanSecond", Boolean.TYPE),
1242                             new DynaProperty("byteProperty", Byte.TYPE),
1243                             new DynaProperty("doubleProperty", Double.TYPE),
1244                             new DynaProperty("dupProperty", stringArray.getClass()),
1245                             new DynaProperty("floatProperty", Float.TYPE),
1246                             new DynaProperty("intArray", intArray.getClass()),
1247                             new DynaProperty("intIndexed", intArray.getClass()),
1248                             new DynaProperty("intProperty", Integer.TYPE),
1249                             new DynaProperty("listIndexed", List.class),
1250                             new DynaProperty("longProperty", Long.TYPE),
1251                             new DynaProperty("mapProperty", Map.class),
1252                             new DynaProperty("mappedProperty", Map.class),
1253                             new DynaProperty("mappedIntProperty", Map.class),
1254                             new DynaProperty("nested", TestBean.class),
1255                             new DynaProperty("nullProperty", String.class),
1256                             new DynaProperty("shortProperty", Short.TYPE),
1257                             new DynaProperty("stringArray", stringArray.getClass()),
1258                             new DynaProperty("stringIndexed", stringArray.getClass()),
1259                             new DynaProperty("stringProperty", String.class),
1260                         });
1261         return (dynaClass);
1262 
1263     }
1264 
1265 
1266 }