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