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.configuration.beanutils;
19  
20  import java.util.ArrayList;
21  import java.util.HashMap;
22  import java.util.List;
23  
24  import org.apache.commons.beanutils.DynaProperty;
25  import org.apache.commons.configuration.BaseConfiguration;
26  import org.apache.commons.configuration.Configuration;
27  import org.apache.commons.configuration.MapConfiguration;
28  
29  import junit.framework.AssertionFailedError;
30  import junit.framework.TestCase;
31  import junitx.framework.ObjectAssert;
32  
33  /***
34   * <p>Test Case for the <code>ConfigurationDynaBean</code> implementation class.
35   * These tests were based on the ones in <code>BasicDynaBeanTestCase</code>
36   * because the two classes provide similar levels of functionality.</p>
37   *
38   * @author <a href="mailto:ricardo.gladwell@btinternet.com">Ricardo Gladwell</a>
39   * @version $Revision: 652316 $
40   */
41  public class TestConfigurationDynaBean extends TestCase
42  {
43      /***
44       * The basic test bean for each test.
45       */
46      private ConfigurationDynaBean bean;
47  
48      /***
49       * The set of property names we expect to have returned when calling
50       * <code>getDynaProperties()</code>.  You should update this list
51       * when new properties are added to TestBean.
52       */
53      String[] properties = {
54              "booleanProperty",
55              "booleanSecond",
56              "doubleProperty",
57              "floatProperty",
58              "intProperty",
59              "longProperty",
60              "mappedProperty.key1",
61              "mappedProperty.key2",
62              "mappedProperty.key3",
63              "mappedIntProperty.key1",
64              "shortProperty",
65              "stringProperty",
66              "byteProperty",
67              "charProperty"
68      };
69  
70      Object[] values = {
71              Boolean.TRUE,
72              Boolean.TRUE,
73              new Double(Double.MAX_VALUE),
74              new Float(Float.MAX_VALUE),
75              new Integer(Integer.MAX_VALUE),
76              new Long(Long.MAX_VALUE),
77              "First Value",
78              "Second Value",
79              "Third Value",
80              new Integer(Integer.MAX_VALUE),
81              new Short(Short.MAX_VALUE),
82              "This is a string",
83              new Byte(Byte.MAX_VALUE),
84              new Character(Character.MAX_VALUE)
85      };
86  
87      int[] intArray = {0, 10, 20, 30, 40};
88      boolean[] booleanArray = {true, false, true, false, true};
89      char[] charArray = {'a', 'b', 'c', 'd', 'e'};
90      byte[] byteArray = {0, 10, 20, 30, 40};
91      long[] longArray = {0, 10, 20, 30, 40};
92      short[] shortArray = {0, 10, 20, 30, 40};
93      float[] floatArray = {0, 10, 20, 30, 40};
94      double[] doubleArray = {0.0, 10.0, 20.0, 30.0, 40.0};
95      String[] stringArray = {"String 0", "String 1", "String 2", "String 3", "String 4"};
96  
97  
98      /***
99       * Set up instance variables required by this test case.
100      */
101     public void setUp() throws Exception
102     {
103         Configuration configuration = createConfiguration();
104 
105         for (int i = 0; i < properties.length; i++)
106         {
107             configuration.setProperty(properties[i], values[i]);
108         }
109 
110         for (int a = 0; a < intArray.length; a++)
111         {
112             configuration.addProperty("intIndexed", new Integer(intArray[a]));
113         }
114 
115         for (int a = 0; a < stringArray.length; a++)
116         {
117             configuration.addProperty("stringIndexed", stringArray[a]);
118         }
119 
120         List list = new ArrayList();
121         for (int i = 0; i < stringArray.length; i++)
122         {
123             list.add(stringArray[i]);
124         }
125         configuration.addProperty("listIndexed", list);
126 
127         bean = new ConfigurationDynaBean(configuration);
128 
129         bean.set("listIndexed", list);
130         bean.set("intArray", intArray);
131         bean.set("booleanArray", booleanArray);
132         bean.set("charArray", charArray);
133         bean.set("longArray", longArray);
134         bean.set("shortArray", shortArray);
135         bean.set("floatArray", floatArray);
136         bean.set("doubleArray", doubleArray);
137         bean.set("byteArray", byteArray);
138         bean.set("stringArray", stringArray);
139     }
140 
141     /***
142      * Creates the underlying configuration object for the dyna bean.
143      * @return the underlying configuration object
144      */
145     protected Configuration createConfiguration()
146     {
147         return new BaseConfiguration();
148     }
149 
150     /***
151      * Corner cases on getDynaProperty invalid arguments.
152      */
153     public void testGetDescriptorArguments()
154     {
155         DynaProperty descriptor = bean.getDynaClass().getDynaProperty("unknown");
156         assertNull("Unknown property descriptor should be null", descriptor);
157 
158         try
159         {
160             bean.getDynaClass().getDynaProperty(null);
161             fail("Should throw IllegalArgumentException");
162         }
163         catch (java.lang.IllegalArgumentException e)
164         {
165             // Expected response
166         }
167         catch (AssertionFailedError e)
168         {
169             // ignore other failed responses
170         }
171         catch (Throwable t)
172         {
173             fail("Threw '" + t + "' instead of 'IllegalArgumentException'");
174         }
175     }
176 
177     /***
178      * Positive getDynaProperty on property <code>booleanProperty</code>.
179      */
180     public void testGetDescriptorBoolean()
181     {
182         testGetDescriptorBase("booleanProperty", Boolean.TYPE);
183     }
184 
185     /***
186      * Positive getDynaProperty on property <code>doubleProperty</code>.
187      */
188     public void testGetDescriptorDouble()
189     {
190         testGetDescriptorBase("doubleProperty", Double.TYPE);
191     }
192 
193     /***
194      * Positive getDynaProperty on property <code>floatProperty</code>.
195      */
196     public void testGetDescriptorFloat()
197     {
198         testGetDescriptorBase("floatProperty", Float.TYPE);
199     }
200 
201     /***
202      * Positive getDynaProperty on property <code>intProperty</code>.
203      */
204     public void testGetDescriptorInt()
205     {
206         testGetDescriptorBase("intProperty", Integer.TYPE);
207     }
208 
209     /***
210      * Positive getDynaProperty on property <code>longProperty</code>.
211      */
212     public void testGetDescriptorLong()
213     {
214         testGetDescriptorBase("longProperty", Long.TYPE);
215     }
216 
217     /***
218      * Positive getDynaProperty on property <code>booleanSecond</code>
219      * that uses an "is" method as the getter.
220      */
221     public void testGetDescriptorSecond()
222     {
223         testGetDescriptorBase("booleanSecond", Boolean.TYPE);
224     }
225 
226     /***
227      * Positive getDynaProperty on property <code>shortProperty</code>.
228      */
229     public void testGetDescriptorShort()
230     {
231         testGetDescriptorBase("shortProperty", Short.TYPE);
232     }
233 
234     /***
235      * Positive getDynaProperty on property <code>stringProperty</code>.
236      */
237     public void testGetDescriptorString()
238     {
239         testGetDescriptorBase("stringProperty", String.class);
240     }
241 
242     /***
243      * Positive test for getDynaPropertys().  Each property name
244      * listed in <code>properties</code> should be returned exactly once.
245      */
246     public void testGetDescriptors()
247     {
248         DynaProperty pd[] = bean.getDynaClass().getDynaProperties();
249         assertNotNull("Got descriptors", pd);
250         int count[] = new int[properties.length];
251         for (int i = 0; i < pd.length; i++)
252         {
253             String name = pd[i].getName();
254             for (int j = 0; j < properties.length; j++)
255             {
256                 if (name.equals(properties[j]))
257                 {
258                     count[j]++;
259                 }
260             }
261         }
262 
263         for (int j = 0; j < properties.length; j++)
264         {
265             if (count[j] < 0)
266             {
267                 fail("Missing property " + properties[j]);
268             }
269             else if (count[j] > 1)
270             {
271                 fail("Duplicate property " + properties[j]);
272             }
273         }
274     }
275 
276     /***
277      * Corner cases on getIndexedProperty invalid arguments.
278      */
279     public void testGetIndexedArguments()
280     {
281         try
282         {
283             bean.get("intArray", -1);
284         }
285         catch (IndexOutOfBoundsException e)
286         {
287             return; // Expected response
288         }
289         catch (Throwable t)
290         {
291             fail("Threw '" + t + "' instead of 'IndexOutOfBoundsException'");
292             return;
293         }
294 
295         fail("Should throw IndexOutOfBoundsException");
296     }
297 
298     /***
299      * Positive and negative tests on getIndexedProperty valid arguments.
300      */
301     public void testGetIndexedValues()
302     {
303         for (int i = 0; i < 5; i++)
304         {
305             Object value = bean.get("intArray", i);
306 
307             assertNotNull("intArray index " + i + " did not return value.", value);
308             ObjectAssert.assertInstanceOf("intArray index " + i, Integer.class, value);
309             assertEquals("intArray " + i + " returned incorrect value.", i * 10, ((Integer) value).intValue());
310 
311             value = bean.get("intIndexed", i);
312 
313             assertNotNull("intIndexed index " + i + "returned value " + i, value);
314             ObjectAssert.assertInstanceOf("intIndexed index " + i, Integer.class, value);
315             assertEquals("intIndexed index " + i + "returned correct " + i, i * 10, ((Integer) value).intValue());
316 
317             value = bean.get("listIndexed", i);
318 
319             assertNotNull("listIndexed index " + i + "returned value " + i, value);
320             ObjectAssert.assertInstanceOf("list index " + i, String.class, value);
321             assertEquals("listIndexed index " + i + "returned correct " + i, "String " + i, (String) value);
322 
323             value = bean.get("stringArray", i);
324 
325             assertNotNull("stringArray index " + i + " returnde null.", value);
326             assertFalse("stringArray index " + i + " returned array instead of String.", value.getClass().isArray());
327             ObjectAssert.assertInstanceOf("stringArray index " + i, String.class, value);
328             assertEquals("stringArray returned correct " + i, "String " + i, (String) value);
329 
330             value = bean.get("stringIndexed", i);
331 
332             assertNotNull("stringIndexed returned value " + i, value);
333             ObjectAssert.assertInstanceOf("stringIndexed", String.class, value);
334             assertEquals("stringIndexed returned correct " + i, "String " + i, (String) value);
335         }
336     }
337 
338     /***
339      * Corner cases on getMappedProperty invalid arguments.
340      */
341     public void testGetMappedArguments()
342     {
343         try
344         {
345             Object value = bean.get("mappedProperty", "unknown");
346             assertNull("Should not return a value", value);
347         }
348         catch (Throwable t)
349         {
350             fail("Threw " + t + " instead of returning null");
351         }
352     }
353 
354     /***
355      * Positive and negative tests on getMappedProperty valid arguments.
356      */
357     public void testGetMappedValues()
358     {
359         Object value = bean.get("mappedProperty", "key1");
360         assertEquals("Can find first value", "First Value", value);
361 
362         value = bean.get("mappedProperty", "key2");
363         assertEquals("Can find second value", "Second Value", value);
364 
365         value = bean.get("mappedProperty", "key3");
366         assertNotNull("Cannot find third value", value);
367     }
368 
369     /***
370      * Corner cases on getSimpleProperty invalid arguments.
371      */
372     public void testGetSimpleArguments()
373     {
374         try
375         {
376             bean.get("a non existing property");
377         }
378         catch (IllegalArgumentException e)
379         {
380             return; // Expected response
381         }
382         catch (Throwable t)
383         {
384             fail("Threw " + t + " instead of IllegalArgumentException");
385         }
386         fail("Should throw IllegalArgumentException");
387     }
388 
389     /***
390      * Test getSimpleProperty on a boolean property.
391      */
392     public void testGetSimpleBoolean()
393     {
394         Object value = bean.get("booleanProperty");
395         assertNotNull("Got a value", value);
396         ObjectAssert.assertInstanceOf("Got correct type", Boolean.class, value);
397         assertTrue("Got correct value", ((Boolean) value).booleanValue());
398     }
399 
400     /***
401      * Test getSimpleProperty on a double property.
402      */
403     public void testGetSimpleDouble()
404     {
405         Object value = bean.get("doubleProperty");
406         assertNotNull("Got a value", value);
407         ObjectAssert.assertInstanceOf("Got correct type", Double.class, value);
408         assertEquals("Got correct value", ((Double) value).doubleValue(), Double.MAX_VALUE, 0.005);
409     }
410 
411     /***
412      * Test getSimpleProperty on a float property.
413      */
414     public void testGetSimpleFloat()
415     {
416         Object value = bean.get("floatProperty");
417         assertNotNull("Got a value", value);
418         ObjectAssert.assertInstanceOf("Got correct type", Float.class, value);
419         assertEquals("Got correct value", ((Float) value).floatValue(), Float.MAX_VALUE, 0.005f);
420     }
421 
422     /***
423      * Test getSimpleProperty on a int property.
424      */
425     public void testGetSimpleInt()
426     {
427         Object value = bean.get("intProperty");
428         assertNotNull("Failed to get value", value);
429         ObjectAssert.assertInstanceOf("Incorrect type", Integer.class, value);
430         assertEquals("Incorrect value", ((Integer) value).intValue(), Integer.MAX_VALUE);
431     }
432 
433     /***
434      * Test getSimpleProperty on a long property.
435      */
436     public void testGetSimpleLong()
437     {
438         Object value = bean.get("longProperty");
439         assertNotNull("Got a value", value);
440         ObjectAssert.assertInstanceOf("Returned incorrect type", Long.class, value);
441         assertEquals("Returned value of Incorrect value", ((Long) value).longValue(), Long.MAX_VALUE);
442     }
443 
444     /***
445      * Test getSimpleProperty on a short property.
446      */
447     public void testGetSimpleShort()
448     {
449         Object value = bean.get("shortProperty");
450         assertNotNull("Got a value", value);
451         ObjectAssert.assertInstanceOf("Got correct type", Short.class, value);
452         assertEquals("Got correct value", ((Short) value).shortValue(), Short.MAX_VALUE);
453     }
454 
455     /***
456      * Test getSimpleProperty on a String property.
457      */
458     public void testGetSimpleString()
459     {
460         Object value = bean.get("stringProperty");
461         assertNotNull("Got a value", value);
462         ObjectAssert.assertInstanceOf("Got correct type", String.class, value);
463         assertEquals("Got correct value", (String) value, "This is a string");
464     }
465 
466     /***
467      * Test <code>contains()</code> method for mapped properties.
468      */
469     public void testMappedContains()
470     {
471         assertTrue("Can't see first key", bean.contains("mappedProperty", "key1"));
472         assertTrue("Can see unknown key", !bean.contains("mappedProperty", "Unknown Key"));
473     }
474 
475     /***
476      * Test <code>remove()</code> method for mapped properties.
477      */
478     public void testMappedRemove()
479     {
480         assertTrue("Can see first key", bean.contains("mappedProperty", "key1"));
481         bean.remove("mappedProperty", "key1");
482         assertTrue("Can not see first key", !bean.contains("mappedProperty", "key1"));
483 
484         assertTrue("Can not see unknown key", !bean.contains("mappedProperty", "key4"));
485         bean.remove("mappedProperty", "key4");
486         assertTrue("Can not see unknown key", !bean.contains("mappedProperty", "key4"));
487     }
488 
489     /***
490      * Corner cases on setIndexedProperty invalid arguments.
491      */
492     public void testSetIndexedArguments()
493     {
494         try
495         {
496             bean.set("intArray", -1, new Integer(0));
497         }
498         catch (IndexOutOfBoundsException e)
499         {
500             return; // Expected response
501         }
502         catch (Throwable t)
503         {
504             fail("Threw " + t + " instead of IndexOutOfBoundsException");
505         }
506 
507         fail("Should throw IndexOutOfBoundsException");
508     }
509 
510     /***
511      * Positive and negative tests on setIndexedProperty valid arguments.
512      */
513     public void testSetIndexedValues()
514     {
515         bean.set("intArray", 0, new Integer(1));
516         Object value = bean.get("intArray", 0);
517 
518         assertNotNull("Returned new value 0", value);
519         ObjectAssert.assertInstanceOf("Returned Integer new value 0", Integer.class,  value);
520         assertEquals("Returned correct new value 0", 1, ((Integer) value).intValue());
521 
522 
523         bean.set("intIndexed", 1, new Integer(11));
524         value = bean.get("intIndexed", 1);
525 
526         assertNotNull("Returned new value 1", value);
527         ObjectAssert.assertInstanceOf("Returned Integer new value 1", Integer.class,  value);
528         assertEquals("Returned correct new value 1", 11, ((Integer) value).intValue());
529 
530 
531         bean.set("listIndexed", 2, "New Value 2");
532         value = bean.get("listIndexed", 2);
533 
534         assertNotNull("Returned new value 2", value);
535         ObjectAssert.assertInstanceOf("Returned String new value 2", String.class,  value);
536         assertEquals("Returned correct new value 2", "New Value 2", (String) value);
537 
538 
539         bean.set("stringArray", 3, "New Value 3");
540         value = bean.get("stringArray", 3);
541 
542         assertNotNull("Returned new value 3", value);
543         ObjectAssert.assertInstanceOf("Returned String new value 3", String.class,  value);
544         assertEquals("Returned correct new value 3", "New Value 3", (String) value);
545 
546 
547         bean.set("stringIndexed", 4, "New Value 4");
548         value = bean.get("stringIndexed", 4);
549 
550         assertNotNull("Returned new value 4", value);
551         ObjectAssert.assertInstanceOf("Returned String new value 4", String.class,  value);
552         assertEquals("Returned correct new value 4", "New Value 4", (String) value);
553     }
554 
555     /***
556      * Test the modification of a configuration property stored internally as an array.
557      */
558     public void testSetArrayValue()
559     {
560         MapConfiguration configuration = new MapConfiguration(new HashMap());
561         configuration.getMap().put("objectArray", new Object[] {"value1", "value2", "value3"});
562 
563         ConfigurationDynaBean bean = new ConfigurationDynaBean(configuration);
564 
565         bean.set("objectArray", 1, "New Value 1");
566         Object value = bean.get("objectArray", 1);
567 
568         assertNotNull("Returned new value 1", value);
569         ObjectAssert.assertInstanceOf("Returned String new value 1", String.class,  value);
570         assertEquals("Returned correct new value 1", "New Value 1", (String) value);
571     }
572 
573     /***
574      * Positive and negative tests on setMappedProperty valid arguments.
575      */
576     public void testSetMappedValues()
577     {
578         bean.set("mappedProperty", "First Key", "New First Value");
579         assertEquals("Can replace old value", "New First Value", (String) bean.get("mappedProperty", "First Key"));
580 
581         bean.set("mappedProperty", "Fourth Key", "Fourth Value");
582         assertEquals("Can set new value", "Fourth Value", (String) bean.get("mappedProperty", "Fourth Key"));
583     }
584 
585     /***
586      * Test setSimpleProperty on a boolean property.
587      */
588     public void testSetSimpleBoolean()
589     {
590         boolean oldValue = ((Boolean) bean.get("booleanProperty")).booleanValue();
591         boolean newValue = !oldValue;
592         bean.set("booleanProperty", new Boolean(newValue));
593         assertTrue("Matched new value", newValue == ((Boolean) bean.get("booleanProperty")).booleanValue());
594     }
595 
596     /***
597      * Test setSimpleProperty on a double property.
598      */
599     public void testSetSimpleDouble()
600     {
601         double oldValue = ((Double) bean.get("doubleProperty")).doubleValue();
602         double newValue = oldValue + 1.0;
603         bean.set("doubleProperty", new Double(newValue));
604         assertEquals("Matched new value", newValue, ((Double) bean.get("doubleProperty")).doubleValue(), 0.005);
605     }
606 
607     /***
608      * Test setSimpleProperty on a float property.
609      */
610     public void testSetSimpleFloat()
611     {
612         float oldValue = ((Float) bean.get("floatProperty")).floatValue();
613         float newValue = oldValue + (float) 1.0;
614         bean.set("floatProperty", new Float(newValue));
615         assertEquals("Matched new value", newValue, ((Float) bean.get("floatProperty")).floatValue(), 0.005f);
616     }
617 
618     /***
619      * Test setSimpleProperty on a int property.
620      */
621     public void testSetSimpleInt()
622     {
623         int oldValue = ((Integer) bean.get("intProperty")).intValue();
624         int newValue = oldValue + 1;
625         bean.set("intProperty", new Integer(newValue));
626         assertEquals("Matched new value", newValue, ((Integer) bean.get("intProperty")).intValue());
627     }
628 
629     /***
630      * Test setSimpleProperty on a long property.
631      */
632     public void testSetSimpleLong()
633     {
634         long oldValue = ((Long) bean.get("longProperty")).longValue();
635         long newValue = oldValue + 1;
636         bean.set("longProperty", new Long(newValue));
637         assertEquals("Matched new value", newValue, ((Long) bean.get("longProperty")).longValue());
638     }
639 
640     /***
641      * Test setSimpleProperty on a short property.
642      */
643     public void testSetSimpleShort()
644     {
645         short oldValue = ((Short) bean.get("shortProperty")).shortValue();
646         short newValue = (short) (oldValue + 1);
647         bean.set("shortProperty", new Short(newValue));
648         assertEquals("Matched new value", newValue, ((Short) bean.get("shortProperty")).shortValue());
649     }
650 
651     /***
652      * Test setSimpleProperty on a String property.
653      */
654     public void testSetSimpleString()
655     {
656         String oldValue = (String) bean.get("stringProperty");
657         String newValue = oldValue + " Extra Value";
658         bean.set("stringProperty", newValue);
659         assertEquals("Matched new value", newValue, (String) bean.get("stringProperty"));
660     }
661 
662     /***
663      * Tests set on a null value: should throw NPE.
664      */
665     public void testAddNullPropertyValue()
666     {
667         try
668         {
669             bean.set("nullProperty", null);
670         }
671         catch (NullPointerException e)
672         {
673             return;
674         }
675         catch (Throwable t)
676         {
677             fail("Threw " + t + " instead of NullPointerException");
678             return;
679         }
680         fail("Should have thrown NullPointerException");
681     }
682 
683     /***
684      * Test the retrieval of a non-existent property.
685      */
686     public void testGetNonExistentProperty()
687     {
688         try
689         {
690             bean.get("nonexistProperty");
691         }
692         catch (IllegalArgumentException e)
693         {
694             return;
695         }
696         catch (Exception e)
697         {
698             fail("Threw '" + e + "' instead of java.lang.IllegalArgumentException");
699         }
700 
701         fail("Get non-existent property failed to throw java.lang.IllegalArgumentException");
702     }
703 
704     /***
705      * Base for testGetDescriptorXxxxx() series of tests.
706      *
707      * @param name Name of the property to be retrieved
708      * @param type Expected class type of this property
709      */
710     protected void testGetDescriptorBase(String name, Class type)
711     {
712         DynaProperty descriptor = bean.getDynaClass().getDynaProperty(name);
713 
714         assertNotNull("Failed to get descriptor", descriptor);
715         assertEquals("Got incorrect type", type, descriptor.getType());
716     }
717 
718     /***
719      * Tests if accessing a non-indexed property using the index
720      * get method throws an IllegalArgumentException as it
721      * should.
722      */
723     public void testNonIndexedPropeties()
724     {
725         ConfigurationDynaBean nested = (ConfigurationDynaBean) bean.get("mappedProperty");
726 
727         String value = (String) nested.get("key1");
728         assertEquals("Can find first value", "First Value", value);
729 
730         nested.set("key1", "undefined");
731         assertEquals("Incorrect value returned", "undefined", bean.get("mappedProperty.key1"));
732     }
733 
734     /***
735      * Tests if accessing a non-indexed property using the index
736      * get method throws an IllegalArgumentException as it
737      * should.
738      */
739     public void testNestedPropeties()
740     {
741         try
742         {
743             bean.get("booleanProperty", 0);
744         }
745         catch (IllegalArgumentException e)
746         {
747             return;
748         }
749         catch (Throwable t)
750         {
751             fail("Threw " + t + " instead of IllegalArgumentException");
752             return;
753         }
754 
755         fail("Should have thrown IllegalArgumentException");
756 
757         try
758         {
759             bean.set("booleanProperty", 0, Boolean.TRUE);
760         }
761         catch (IllegalArgumentException e)
762         {
763             return;
764         }
765         catch (Throwable t)
766         {
767             fail("Threw " + t + " instead of IllegalArgumentException");
768             return;
769         }
770 
771         fail("Should have thrown IllegalArgumentException");
772     }
773 
774 
775 }