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}