1 package org.apache.commons.beanutils2;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import static org.apache.commons.beanutils2.Argument.argument;
23 import static org.apache.commons.beanutils2.Argument.getParameterTypes;
24 import static org.apache.commons.beanutils2.Argument.getParameters;
25 import static org.apache.commons.beanutils2.Argument.nullArgument;
26 import static org.junit.Assert.assertEquals;
27 import static org.junit.Assert.assertNotNull;
28 import static org.junit.Assert.assertNull;
29 import static org.junit.Assert.assertTrue;
30
31 import org.apache.commons.beanutils2.testbeans.TestBean;
32 import org.junit.Test;
33
34 public class ArgumentTest
35 {
36
37 private static byte fByte = 7;
38
39 private static short fShort = 39;
40
41 private static int fInt = 96;
42
43 private static long fLong = 1569875l;
44
45 private static float fFloat = 47.11f;
46
47 private static double fDouble = 0.345e-36d;
48
49 private static char fChar = 'X';
50
51 private static String fString = "Testing is important!";
52
53 private static Object fObject = new Object();
54
55 private static TestBean fTestBean = new TestBean( true, fString );
56
57 @Test
58 public void argumentBoolean()
59 {
60 Argument<Boolean> booleanArg = argument( true );
61 assertTrue( booleanArg.getValue().booleanValue() );
62 assertEquals( Boolean.class, booleanArg.getType() );
63 }
64
65 @Test
66 public void argumentByte()
67 {
68 Argument<Byte> byteArg = argument( new Byte( fByte ) );
69 assertEquals( fByte, byteArg.getValue().byteValue() );
70 assertEquals( Byte.class, byteArg.getType() );
71 }
72
73 @Test
74 public void argumentShort()
75 {
76 Argument<Short> shortArg = argument( new Short( fShort ) );
77 assertEquals( fShort, shortArg.getValue().shortValue() );
78 assertEquals( Short.class, shortArg.getType() );
79 }
80
81 @Test
82 public void argumentInt()
83 {
84 Argument<Integer> intArg = argument( fInt );
85 assertEquals( fInt, intArg.getValue().intValue() );
86 assertEquals( Integer.class, intArg.getType() );
87 }
88
89 @Test
90 public void argumentLong()
91 {
92 Argument<Long> longArg = argument( fLong );
93 assertEquals( fLong, longArg.getValue().longValue() );
94 assertEquals( Long.class, longArg.getType() );
95 }
96
97 @Test
98 public void argumentFloat()
99 {
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 }