001package org.apache.commons.beanutils2; 002 003/* 004 * Licensed to the Apache Software Foundation (ASF) under one 005 * or more contributor license agreements. See the NOTICE file 006 * distributed with this work for additional information 007 * regarding copyright ownership. The ASF licenses this file 008 * to you under the Apache License, Version 2.0 (the 009 * "License"); you may not use this file except in compliance 010 * with the License. You may obtain a copy of the License at 011 * 012 * http://www.apache.org/licenses/LICENSE-2.0 013 * 014 * Unless required by applicable law or agreed to in writing, 015 * software distributed under the License is distributed on an 016 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 017 * KIND, either express or implied. See the License for the 018 * specific language governing permissions and limitations 019 * under the License. 020 */ 021 022import static org.apache.commons.beanutils2.Argument.argument; 023import static org.apache.commons.beanutils2.Argument.getParameterTypes; 024import static org.apache.commons.beanutils2.Argument.getParameters; 025import static org.apache.commons.beanutils2.Argument.nullArgument; 026import static org.junit.Assert.assertEquals; 027import static org.junit.Assert.assertNotNull; 028import static org.junit.Assert.assertNull; 029import static org.junit.Assert.assertTrue; 030 031import org.apache.commons.beanutils2.testbeans.TestBean; 032import org.junit.Test; 033 034public class ArgumentTest 035{ 036 037 private static byte fByte = 7; 038 039 private static short fShort = 39; 040 041 private static int fInt = 96; 042 043 private static long fLong = 1569875l; 044 045 private static float fFloat = 47.11f; 046 047 private static double fDouble = 0.345e-36d; 048 049 private static char fChar = 'X'; 050 051 private static String fString = "Testing is important!"; 052 053 private static Object fObject = new Object(); 054 055 private static TestBean fTestBean = new TestBean( true, fString ); 056 057 @Test 058 public void argumentBoolean() 059 { 060 Argument<Boolean> booleanArg = argument( true ); 061 assertTrue( booleanArg.getValue().booleanValue() ); 062 assertEquals( Boolean.class, booleanArg.getType() ); 063 } 064 065 @Test 066 public void argumentByte() 067 { 068 Argument<Byte> byteArg = argument( new Byte( fByte ) ); 069 assertEquals( fByte, byteArg.getValue().byteValue() ); 070 assertEquals( Byte.class, byteArg.getType() ); 071 } 072 073 @Test 074 public void argumentShort() 075 { 076 Argument<Short> shortArg = argument( new Short( fShort ) ); 077 assertEquals( fShort, shortArg.getValue().shortValue() ); 078 assertEquals( Short.class, shortArg.getType() ); 079 } 080 081 @Test 082 public void argumentInt() 083 { 084 Argument<Integer> intArg = argument( fInt ); 085 assertEquals( fInt, intArg.getValue().intValue() ); 086 assertEquals( Integer.class, intArg.getType() ); 087 } 088 089 @Test 090 public void argumentLong() 091 { 092 Argument<Long> longArg = argument( fLong ); 093 assertEquals( fLong, longArg.getValue().longValue() ); 094 assertEquals( Long.class, longArg.getType() ); 095 } 096 097 @Test 098 public void argumentFloat() 099 { 100 Argument<Float> floatArg = argument( fFloat ); 101 assertEquals( fFloat, floatArg.getValue().floatValue(), 0.0d ); 102 assertEquals( Float.class, floatArg.getType() ); 103 } 104 105 @Test 106 public void argumentDouble() 107 { 108 Argument<Double> doubleArg = argument( fDouble ); 109 assertEquals( fDouble, doubleArg.getValue().doubleValue(), 0.0d ); 110 assertEquals( Double.class, doubleArg.getType() ); 111 } 112 113 @Test 114 public void argumentChar() 115 { 116 Argument<Character> charArg = argument( fChar ); 117 assertEquals( fChar, charArg.getValue().charValue() ); 118 assertEquals( Character.class, charArg.getType() ); 119 } 120 121 @Test 122 public void argumentString() 123 { 124 Argument<String> stringArg = argument( fString ); 125 assertEquals( fString, stringArg.getValue() ); 126 assertEquals( String.class, stringArg.getType() ); 127 } 128 129 @Test 130 public void argumentObject() 131 { 132 Argument<Object> objArg = argument( fObject ); 133 assertEquals( fObject, objArg.getValue() ); 134 assertEquals( Object.class, objArg.getType() ); 135 } 136 137 @Test 138 public void argumentTestBean() 139 { 140 Argument<TestBean> testBeanArg = argument( fTestBean ); 141 assertEquals( fTestBean, testBeanArg.getValue() ); 142 assertEquals( TestBean.class, testBeanArg.getType() ); 143 } 144 145 @Test( expected = NullPointerException.class ) 146 public void argumentNull() 147 { 148 argument( null ); 149 } 150 151 @Test 152 public void nullArgumentClassOfBooleanClass() 153 { 154 Argument<Boolean> booleanArg = nullArgument( Boolean.class ); 155 assertNull( booleanArg.getValue() ); 156 assertEquals( Boolean.class, booleanArg.getType() ); 157 158 } 159 160 @Test 161 public void nullArgumentClassOfBooleanType() 162 { 163 Argument<Boolean> booleanArg = nullArgument( Boolean.TYPE ); 164 assertNull( booleanArg.getValue() ); 165 assertEquals( Boolean.TYPE, booleanArg.getType() ); 166 } 167 168 @Test 169 public void nullArgumentClassOfByteClass() 170 { 171 Argument<Byte> byteArg = nullArgument( Byte.class ); 172 assertNull( byteArg.getValue() ); 173 assertEquals( Byte.class, byteArg.getType() ); 174 } 175 176 @Test 177 public void nullArgumentClassOfByteType() 178 { 179 Argument<Byte> byteArg = nullArgument( Byte.TYPE ); 180 assertNull( byteArg.getValue() ); 181 assertEquals( Byte.TYPE, byteArg.getType() ); 182 } 183 184 @Test 185 public void nullArgumentClassOfShortClass() 186 { 187 Argument<Short> shortArg = nullArgument( Short.class ); 188 assertNull( shortArg.getValue() ); 189 assertEquals( Short.class, shortArg.getType() ); 190 } 191 192 @Test 193 public void nullArgumentClassOfShortType() 194 { 195 Argument<Short> shortArg = nullArgument( Short.TYPE ); 196 assertNull( shortArg.getValue() ); 197 assertEquals( Short.TYPE, shortArg.getType() ); 198 } 199 200 @Test 201 public void nullArgumentClassOfIntegerClass() 202 { 203 Argument<Integer> intArg = nullArgument( Integer.class ); 204 assertNull( intArg.getValue() ); 205 assertEquals( Integer.class, intArg.getType() ); 206 } 207 208 @Test 209 public void nullArgumentClassOfIntegerType() 210 { 211 Argument<Integer> intArg = nullArgument( Integer.TYPE ); 212 assertNull( intArg.getValue() ); 213 assertEquals( Integer.TYPE, intArg.getType() ); 214 } 215 216 @Test 217 public void nullArgumentClassOfLongClass() 218 { 219 Argument<Long> longArg = nullArgument( Long.class ); 220 assertNull( longArg.getValue() ); 221 assertEquals( Long.class, longArg.getType() ); 222 } 223 224 @Test 225 public void nullArgumentClassOfLongType() 226 { 227 Argument<Long> longArg = nullArgument( Long.TYPE ); 228 assertNull( longArg.getValue() ); 229 assertEquals( Long.TYPE, longArg.getType() ); 230 } 231 232 @Test 233 public void nullArgumentClassOfFloatClass() 234 { 235 Argument<Float> floatArg = nullArgument( Float.class ); 236 assertNull( floatArg.getValue() ); 237 assertEquals( Float.class, floatArg.getType() ); 238 } 239 240 @Test 241 public void nullArgumentClassOfFloatType() 242 { 243 Argument<Float> floatArg = nullArgument( Float.TYPE ); 244 assertNull( floatArg.getValue() ); 245 assertEquals( Float.TYPE, floatArg.getType() ); 246 } 247 248 @Test 249 public void nullArgumentClassOfDoubleClass() 250 { 251 Argument<Double> doubleArg = nullArgument( Double.class ); 252 assertNull( doubleArg.getValue() ); 253 assertEquals( Double.class, doubleArg.getType() ); 254 } 255 256 @Test 257 public void nullArgumentClassOfDoubleType() 258 { 259 Argument<Double> doubleArg = nullArgument( Double.TYPE ); 260 assertNull( doubleArg.getValue() ); 261 assertEquals( Double.TYPE, doubleArg.getType() ); 262 } 263 264 @Test 265 public void nullArgumentClassOfCharacterClass() 266 { 267 Argument<Character> charArg = nullArgument( Character.class ); 268 assertNull( charArg.getValue() ); 269 assertEquals( Character.class, charArg.getType() ); 270 } 271 272 @Test 273 public void nullArgumentClassOfCharacterType() 274 { 275 Argument<Character> charArg = nullArgument( Character.TYPE ); 276 assertNull( charArg.getValue() ); 277 assertEquals( Character.TYPE, charArg.getType() ); 278 } 279 280 @Test 281 public void nullArgumentClassOfStringClass() 282 { 283 Argument<String> stringArg = nullArgument( String.class ); 284 assertNull( stringArg.getValue() ); 285 assertEquals( String.class, stringArg.getType() ); 286 } 287 288 @Test 289 public void nullArgumentClassOfObjectClass() 290 { 291 Argument<Object> objArg = nullArgument( Object.class ); 292 assertNull( objArg.getValue() ); 293 assertEquals( Object.class, objArg.getType() ); 294 } 295 296 @Test 297 public void nullArgumentClassOfTestBeanClass() 298 { 299 Argument<TestBean> testBeanArg = nullArgument( TestBean.class ); 300 assertNull( testBeanArg.getValue() ); 301 assertEquals( TestBean.class, testBeanArg.getType() ); 302 } 303 304 @Test( expected = NullPointerException.class ) 305 public void nullArgumentClassOfANull() 306 { 307 nullArgument( null ); 308 } 309 310 @Test 311 public void argumentClassOfBooleanClass() 312 { 313 Argument<Boolean> booleanArg = argument( Boolean.class, Boolean.TRUE ); 314 assertTrue( booleanArg.getValue().booleanValue() ); 315 assertEquals( Boolean.class, booleanArg.getType() ); 316 } 317 318 @Test 319 public void argumentClassOfBooleanType() 320 { 321 Argument<Boolean> booleanArg = argument( Boolean.TYPE, Boolean.TRUE ); 322 assertTrue( booleanArg.getValue().booleanValue() ); 323 assertEquals( Boolean.TYPE, booleanArg.getType() ); 324 } 325 326 @Test 327 public void argumentClassOfByteClass() 328 { 329 Argument<Byte> byteArg = argument( Byte.class, new Byte( fByte ) ); 330 assertEquals( fByte, byteArg.getValue().byteValue() ); 331 assertEquals( Byte.class, byteArg.getType() ); 332 } 333 334 @Test 335 public void argumentClassOfByteType() 336 { 337 Argument<Byte> byteArg = argument( Byte.TYPE, new Byte( fByte ) ); 338 assertEquals( fByte, byteArg.getValue().byteValue() ); 339 assertEquals( Byte.TYPE, byteArg.getType() ); 340 } 341 342 @Test 343 public void argumentClassOfShortClass() 344 { 345 Argument<Short> shortArg = argument( Short.class, new Short( fShort ) ); 346 assertEquals( fShort, shortArg.getValue().shortValue() ); 347 assertEquals( Short.class, shortArg.getType() ); 348 } 349 350 @Test 351 public void argumentClassOfShortType() 352 { 353 Argument<Short> shortArg = argument( Short.TYPE, new Short( fShort ) ); 354 assertEquals( fShort, shortArg.getValue().shortValue() ); 355 assertEquals( Short.TYPE, shortArg.getType() ); 356 } 357 358 @Test 359 public void argumentClassOfIntegerClass() 360 { 361 Argument<Integer> intArg = argument( Integer.class, fInt ); 362 assertEquals( fInt, intArg.getValue().intValue() ); 363 assertEquals( Integer.class, intArg.getType() ); 364 } 365 366 @Test 367 public void argumentClassOfIntegerType() 368 { 369 Argument<Integer> intArg = argument( Integer.TYPE, fInt ); 370 assertEquals( fInt, intArg.getValue().intValue() ); 371 assertEquals( Integer.TYPE, intArg.getType() ); 372 } 373 374 @Test 375 public void argumentClassOfLongClass() 376 { 377 Argument<Long> longArg = argument( Long.class, fLong ); 378 assertEquals( fLong, longArg.getValue().longValue() ); 379 assertEquals( Long.class, longArg.getType() ); 380 } 381 382 @Test 383 public void argumentClassOfLongType() 384 { 385 Argument<Long> longArg = argument( Long.TYPE, fLong ); 386 assertEquals( fLong, longArg.getValue().longValue() ); 387 assertEquals( Long.TYPE, longArg.getType() ); 388 } 389 390 @Test 391 public void argumentClassOfFloatClass() 392 { 393 Argument<Float> floatArg = argument( Float.class, fFloat ); 394 assertEquals( fFloat, floatArg.getValue().floatValue(), 0.0d ); 395 assertEquals( Float.class, floatArg.getType() ); 396 } 397 398 @Test 399 public void argumentClassOfFloatType() 400 { 401 Argument<Float> floatArg = argument( Float.TYPE, fFloat ); 402 assertEquals( fFloat, floatArg.getValue().floatValue(), 0.0d ); 403 assertEquals( Float.TYPE, floatArg.getType() ); 404 } 405 406 @Test 407 public void argumentClassOfDoubleClass() 408 { 409 Argument<Double> doubleArg = argument( Double.class, fDouble ); 410 assertEquals( fDouble, doubleArg.getValue().doubleValue(), 0.0d ); 411 assertEquals( Double.class, doubleArg.getType() ); 412 } 413 414 @Test 415 public void argumentClassOfDoubleType() 416 { 417 Argument<Double> doubleArg = argument( Double.TYPE, fDouble ); 418 assertEquals( fDouble, doubleArg.getValue().doubleValue(), 0.0d ); 419 assertEquals( Double.TYPE, doubleArg.getType() ); 420 } 421 422 @Test 423 public void argumentOfClassCharacterClass() 424 { 425 Argument<Character> charArg = argument( Character.class, fChar ); 426 assertEquals( fChar, charArg.getValue().charValue() ); 427 assertEquals( Character.class, charArg.getType() ); 428 } 429 430 @Test 431 public void argumentOfClassCharacterType() 432 { 433 Argument<Character> charArg = argument( Character.TYPE, fChar ); 434 assertEquals( fChar, charArg.getValue().charValue() ); 435 assertEquals( Character.TYPE, charArg.getType() ); 436 } 437 438 @Test 439 public void argumentOfClassStringClass() 440 { 441 Argument<String> stringArg = argument( String.class, fString ); 442 assertEquals( fString, stringArg.getValue() ); 443 assertEquals( String.class, stringArg.getType() ); 444 } 445 446 @Test 447 public void argumentClassOfObjectClass() 448 { 449 Argument<Object> objArg = argument( Object.class, fObject ); 450 assertEquals( fObject, objArg.getValue() ); 451 assertEquals( Object.class, objArg.getType() ); 452 } 453 454 @Test 455 public void argumentClassOfTestBeanClass() 456 { 457 Argument<TestBean> testBeanArg = argument( TestBean.class, fTestBean ); 458 assertEquals( fTestBean, testBeanArg.getValue() ); 459 assertEquals( TestBean.class, testBeanArg.getType() ); 460 } 461 462 @Test( expected = NullPointerException.class ) 463 public void argumentClassOfNullNull() 464 { 465 argument( null, null ); 466 } 467 468 @Test( expected = NullPointerException.class ) 469 public void argumentClassOfNullInt() 470 { 471 argument( null, 25 ); 472 } 473 474 @Test 475 public void getParameterTypesArgumentsOfWrapperClasses() 476 { 477 Argument<Boolean> booleanArg = nullArgument( Boolean.class ); 478 Argument<Byte> byteArg = nullArgument( Byte.class ); 479 Argument<Short> shortArg = nullArgument( Short.class ); 480 Argument<Integer> intArg = nullArgument( Integer.class ); 481 Argument<Long> longArg = nullArgument( Long.class ); 482 Argument<Float> floatArg = nullArgument( Float.class ); 483 Argument<Double> doubleArg = nullArgument( Double.class ); 484 Argument<Character> charArg = nullArgument( Character.class ); 485 Argument<String> stringArg = nullArgument( String.class ); 486 Argument<Object> objArg = nullArgument( Object.class ); 487 Argument<TestBean> testBeanArg = nullArgument( TestBean.class ); 488 489 Class<?>[] types = 490 getParameterTypes( booleanArg, byteArg, shortArg, intArg, longArg, floatArg, doubleArg, charArg, stringArg, 491 objArg, testBeanArg ); 492 assertNotNull( types ); 493 assertEquals( Boolean.class, types[0] ); 494 assertEquals( Byte.class, types[1] ); 495 assertEquals( Short.class, types[2] ); 496 assertEquals( Integer.class, types[3] ); 497 assertEquals( Long.class, types[4] ); 498 assertEquals( Float.class, types[5] ); 499 assertEquals( Double.class, types[6] ); 500 assertEquals( Character.class, types[7] ); 501 assertEquals( String.class, types[8] ); 502 assertEquals( Object.class, types[9] ); 503 assertEquals( TestBean.class, types[10] ); 504 } 505 506 @Test 507 public void getParameterTypesOfPrimitiveClasses() 508 { 509 Argument<Boolean> booleanArg = nullArgument( Boolean.TYPE ); 510 Argument<Byte> byteArg = nullArgument( Byte.TYPE ); 511 Argument<Short> shortArg = nullArgument( Short.TYPE ); 512 Argument<Integer> intArg = nullArgument( Integer.TYPE ); 513 Argument<Long> longArg = nullArgument( Long.TYPE ); 514 Argument<Float> floatArg = nullArgument( Float.TYPE ); 515 Argument<Double> doubleArg = nullArgument( Double.TYPE ); 516 Argument<Character> charArg = nullArgument( Character.TYPE ); 517 518 Class<?>[] types = 519 getParameterTypes( booleanArg, byteArg, shortArg, intArg, longArg, floatArg, doubleArg, charArg ); 520 assertNotNull( types ); 521 assertEquals( Boolean.TYPE, types[0] ); 522 assertEquals( Byte.TYPE, types[1] ); 523 assertEquals( Short.TYPE, types[2] ); 524 assertEquals( Integer.TYPE, types[3] ); 525 assertEquals( Long.TYPE, types[4] ); 526 assertEquals( Float.TYPE, types[5] ); 527 assertEquals( Double.TYPE, types[6] ); 528 assertEquals( Character.TYPE, types[7] ); 529 } 530 531 @Test( expected = NullPointerException.class ) 532 public void getParameterTypesArgumentsOfNull() 533 { 534 getParameterTypes( (Argument<?>) null ); 535 } 536 537 @Test( expected = NullPointerException.class ) 538 public void getParameterTypesArgumentsOfArgumentIntNull() 539 { 540 getParameterTypes( argument( 15 ), (Argument<?>) null ); 541 } 542 543 @Test( expected = NullPointerException.class ) 544 public void getParameterTypesArgumentsOfNullNull() 545 { 546 getParameterTypes( (Argument<?>) null, (Argument<?>) null ); 547 } 548 549 @Test 550 public void getParametersArguments() 551 { 552 Argument<Boolean> booleanArg = argument( true ); 553 Argument<Byte> byteArg = argument( fByte ); 554 Argument<Short> shortArg = argument( fShort ); 555 Argument<Integer> intArg = argument( fInt ); 556 Argument<Long> longArg = argument( fLong ); 557 Argument<Float> floatArg = argument( fFloat ); 558 Argument<Double> doubleArg = argument( fDouble ); 559 Argument<Character> charArg = argument( fChar ); 560 Argument<String> stringArg = argument( fString ); 561 Argument<Object> objArg = argument( fObject ); 562 Argument<TestBean> testBeanArg = argument( fTestBean ); 563 Argument<Object> nullArg = nullArgument( Object.class ); 564 565 Object[] parameters = 566 getParameters( booleanArg, byteArg, shortArg, intArg, longArg, floatArg, doubleArg, charArg, stringArg, 567 objArg, testBeanArg, nullArg ); 568 569 assertEquals( true, parameters[0] ); 570 assertEquals( fByte, parameters[1] ); 571 assertEquals( fShort, parameters[2] ); 572 assertEquals( fInt, parameters[3] ); 573 assertEquals( fLong, parameters[4] ); 574 assertEquals( fFloat, parameters[5] ); 575 assertEquals( fDouble, parameters[6] ); 576 assertEquals( fChar, parameters[7] ); 577 assertEquals( fString, parameters[8] ); 578 assertEquals( fObject, parameters[9] ); 579 assertEquals( fTestBean, parameters[10] ); 580 assertNull( parameters[11] ); 581 } 582 583 @Test( expected = NullPointerException.class ) 584 public void getParametersNull() 585 { 586 getParameters( (Argument<?>) null ); 587 } 588 589 @Test( expected = NullPointerException.class ) 590 public void getParametersIntNull() 591 { 592 getParameters( argument( fInt ), null ); 593 } 594 595 @Test( expected = NullPointerException.class ) 596 public void getParametersNullNull() 597 { 598 getParameters( null, null ); 599 } 600 601}