1 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 36 public class TestConfigurationDynaBean extends TestCase 37 { 38 41 protected ConfigurationDynaBean bean = null; 42 43 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 96 public TestConfigurationDynaBean(String name) 97 { 98 super(name); 99 } 100 101 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 148 public void tearDown() 149 { 150 bean = null; 151 } 152 153 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 ; } 177 catch (AssertionFailedError e) 178 { 179 ; } 181 catch (Throwable t) 182 { 183 fail("Threw '" + t + "' instead of 'IllegalArgumentException'"); 184 } 185 } 186 187 190 public void testGetDescriptorBoolean() 191 { 192 testGetDescriptorBase("booleanProperty", Boolean.TYPE); 193 } 194 195 198 public void testGetDescriptorDouble() 199 { 200 testGetDescriptorBase("doubleProperty", Double.TYPE); 201 } 202 203 206 public void testGetDescriptorFloat() 207 { 208 testGetDescriptorBase("floatProperty", Float.TYPE); 209 } 210 211 214 public void testGetDescriptorInt() 215 { 216 testGetDescriptorBase("intProperty", Integer.TYPE); 217 } 218 219 222 public void testGetDescriptorLong() 223 { 224 testGetDescriptorBase("longProperty", Long.TYPE); 225 } 226 227 231 public void testGetDescriptorSecond() 232 { 233 testGetDescriptorBase("booleanSecond", Boolean.TYPE); 234 } 235 236 239 public void testGetDescriptorShort() 240 { 241 testGetDescriptorBase("shortProperty", Short.TYPE); 242 } 243 244 247 public void testGetDescriptorString() 248 { 249 testGetDescriptorBase("stringProperty", String .class); 250 } 251 252 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 289 public void testGetIndexedArguments() 290 { 291 try 292 { 293 bean.get("intArray", -1); 294 } 295 catch (IndexOutOfBoundsException e) 296 { 297 return; } 299 catch (Throwable t) 300 { 301 fail("Threw '" + t + "' instead of 'IndexOutOfBoundsException'"); 302 return; 303 } 304 305 fail("Should throw IndexOutOfBoundsException"); 306 } 307 308 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 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 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 445 public void testGetSimpleArguments() 446 { 447 try 448 { 449 bean.get(null); 450 } 451 catch (IllegalArgumentException e) 452 { 453 return; } 455 catch (Throwable t) 456 { 457 fail("Threw " + t + " instead of IllegalArgumentException"); 458 } 459 fail("Should throw IllegalArgumentException"); 460 } 461 462 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 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 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 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 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 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 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 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 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 643 public void testSetIndexedArguments() 644 { 645 try 646 { 647 bean.set("intArray", -1, new Integer (0)); 648 } 649 catch (IndexOutOfBoundsException e) 650 { 651 return; } 653 catch (Throwable t) 654 { 655 fail("Threw " + t + " instead of IndexOutOfBoundsException"); 656 } 657 658 fail("Should throw IndexOutOfBoundsException"); 659 } 660 661 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 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 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 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 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 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 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 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 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 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 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 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 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 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} 1026 | Popular Tags |