Source code

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.TypeUtils.checkTypesCompatible;
023import static org.apache.commons.beanutils2.TypeUtils.getPrimitiveType;
024import static org.apache.commons.beanutils2.TypeUtils.getPrimitiveWrapper;
025import static org.apache.commons.beanutils2.TypeUtils.isAssignmentCompatible;
026import static org.apache.commons.beanutils2.TypeUtils.toNonPrimitiveClass;
027import static org.junit.Assert.assertEquals;
028import static org.junit.Assert.assertFalse;
029import static org.junit.Assert.assertNull;
030import static org.junit.Assert.assertSame;
031import static org.junit.Assert.assertTrue;
032
033import org.apache.commons.beanutils2.testbeans.TestBean;
034import org.junit.Test;
035
036public class TypeUtilsTest
037{
038
039    @Test
040    public void isAssignmentCompatibleBooleanPrimitiveBoolean()
041    {
042        assertTrue( isAssignmentCompatible( boolean.class, Boolean.class ) );
043        assertTrue( isAssignmentCompatible( boolean.class, Boolean.TYPE ) );
044        assertTrue( isAssignmentCompatible( boolean.class, boolean.class ) );
045    }
046
047    @Test
048    public void isAssignmentCompatibleBooleanPrimitiveByte()
049    {
050        assertFalse( isAssignmentCompatible( boolean.class, Byte.class ) );
051        assertFalse( isAssignmentCompatible( boolean.class, Byte.TYPE ) );
052        assertFalse( isAssignmentCompatible( boolean.class, byte.class ) );
053    }
054
055    @Test
056    public void isAssignmentCompatibleBooleanPrimitiveShort()
057    {
058        assertFalse( isAssignmentCompatible( boolean.class, Short.class ) );
059        assertFalse( isAssignmentCompatible( boolean.class, Short.TYPE ) );
060        assertFalse( isAssignmentCompatible( boolean.class, short.class ) );
061    }
062
063    @Test
064    public void isAssignmentCompatibleBooleanPrimitiveInteger()
065    {
066        assertFalse( isAssignmentCompatible( boolean.class, Integer.class ) );
067        assertFalse( isAssignmentCompatible( boolean.class, Integer.TYPE ) );
068        assertFalse( isAssignmentCompatible( boolean.class, int.class ) );
069    }
070
071    @Test
072    public void isAssignmentCompatibleBooleanPrimitiveLong()
073    {
074        assertFalse( isAssignmentCompatible( boolean.class, Long.class ) );
075        assertFalse( isAssignmentCompatible( boolean.class, Long.TYPE ) );
076        assertFalse( isAssignmentCompatible( boolean.class, long.class ) );
077    }
078
079    @Test
080    public void isAssignmentCompatibleBooleanPrimitveFloat()
081    {
082        assertFalse( isAssignmentCompatible( boolean.class, Float.class ) );
083        assertFalse( isAssignmentCompatible( boolean.class, Float.TYPE ) );
084        assertFalse( isAssignmentCompatible( boolean.class, float.class ) );
085    }
086
087    @Test
088    public void isAssignmentCompatibleBooleanPrimitveDouble()
089    {
090        assertFalse( isAssignmentCompatible( boolean.class, Double.class ) );
091        assertFalse( isAssignmentCompatible( boolean.class, Double.TYPE ) );
092        assertFalse( isAssignmentCompatible( boolean.class, double.class ) );
093    }
094
095    @Test
096    public void isAssignmentCompatibleBooleanPrimitveCharacter()
097    {
098        assertFalse( isAssignmentCompatible( boolean.class, Character.class ) );
099        assertFalse( isAssignmentCompatible( boolean.class, Character.TYPE ) );
100        assertFalse( isAssignmentCompatible( boolean.class, char.class ) );
101    }
102
103    @Test
104    public void isAssignmentCompatibleBooleanPrimitiveString()
105    {
106        assertFalse( isAssignmentCompatible( boolean.class, String.class ) );
107    }
108
109    @Test
110    public void isAssignmentCompatibleBooleanPrimitiveObject()
111    {
112        assertFalse( isAssignmentCompatible( boolean.class, Object.class ) );
113    }
114
115    @Test
116    public void isAssignmentCompatibleBooleanPrimitiveTestBean()
117    {
118        assertFalse( isAssignmentCompatible( boolean.class, TestBean.class ) );
119    }
120
121    @Test
122    public void isAssignmentCompatibleBooleanWrapperBoolean()
123    {
124
125        assertTrue( isAssignmentCompatible( Boolean.class, Boolean.class ) );
126        assertFalse( isAssignmentCompatible( Boolean.class, boolean.class ) );
127        assertFalse( isAssignmentCompatible( Boolean.class, Boolean.TYPE ) );
128    }
129
130    @Test
131    public void isAssignmentCompatibleBooleanWrapperByte()
132    {
133        assertFalse( isAssignmentCompatible( Boolean.class, Byte.class ) );
134        assertFalse( isAssignmentCompatible( Boolean.class, Byte.TYPE ) );
135        assertFalse( isAssignmentCompatible( Boolean.class, byte.class ) );
136    }
137
138    @Test
139    public void isAssignmentCompatibleBooleanWrapperShort()
140    {
141        assertFalse( isAssignmentCompatible( Boolean.class, Short.class ) );
142        assertFalse( isAssignmentCompatible( Boolean.class, Short.TYPE ) );
143        assertFalse( isAssignmentCompatible( Boolean.class, short.class ) );
144    }
145
146    @Test
147    public void isAssignmentCompatibleBooleanWrapperInteger()
148    {
149        assertFalse( isAssignmentCompatible( Boolean.class, Integer.class ) );
150        assertFalse( isAssignmentCompatible( Boolean.class, Integer.TYPE ) );
151        assertFalse( isAssignmentCompatible( Boolean.class, int.class ) );
152    }
153
154    @Test
155    public void isAssignmentCompatibleBooleanWrapperLong()
156    {
157        assertFalse( isAssignmentCompatible( Boolean.class, Long.class ) );
158        assertFalse( isAssignmentCompatible( Boolean.class, Long.TYPE ) );
159        assertFalse( isAssignmentCompatible( Boolean.class, long.class ) );
160    }
161
162    @Test
163    public void isAssignmentCompatibleBooleanWrapperFloat()
164    {
165        assertFalse( isAssignmentCompatible( Boolean.class, Float.class ) );
166        assertFalse( isAssignmentCompatible( Boolean.class, Float.TYPE ) );
167        assertFalse( isAssignmentCompatible( Boolean.class, float.class ) );
168    }
169
170    @Test
171    public void isAssignmentCompatibleBooleanWrapperDouble()
172    {
173        assertFalse( isAssignmentCompatible( Boolean.class, Double.class ) );
174        assertFalse( isAssignmentCompatible( Boolean.class, Double.TYPE ) );
175        assertFalse( isAssignmentCompatible( Boolean.class, double.class ) );
176    }
177
178    @Test
179    public void isAssignmentCompatibleBooleanWrapperCharacter()
180    {
181        assertFalse( isAssignmentCompatible( Boolean.class, Character.class ) );
182        assertFalse( isAssignmentCompatible( Boolean.class, Character.TYPE ) );
183        assertFalse( isAssignmentCompatible( Boolean.class, char.class ) );
184    }
185
186    @Test
187    public void isAssignmentCompatibleBooleanWrapperString()
188    {
189        assertFalse( isAssignmentCompatible( Boolean.class, String.class ) );
190    }
191
192    @Test
193    public void isAssignmentCompatibleBooleanWrapperObject()
194    {
195        assertFalse( isAssignmentCompatible( Boolean.class, Object.class ) );
196    }
197
198    @Test
199    public void isAssignmentCompatibleBooleanWrapperTestBean()
200    {
201        assertFalse( isAssignmentCompatible( Boolean.class, TestBean.class ) );
202    }
203
204    @Test
205    public void isAssignmentCompatibleBytePrimitiveBoolean()
206    {
207        assertFalse( isAssignmentCompatible( byte.class, Boolean.class ) );
208        assertFalse( isAssignmentCompatible( byte.class, Boolean.TYPE ) );
209        assertFalse( isAssignmentCompatible( byte.class, boolean.class ) );
210    }
211
212    @Test
213    public void isAssignmentCompatibleBytePrimitiveByte()
214    {
215        assertTrue( isAssignmentCompatible( byte.class, Byte.class ) );
216        assertTrue( isAssignmentCompatible( byte.class, Byte.TYPE ) );
217        assertTrue( isAssignmentCompatible( byte.class, byte.class ) );
218    }
219
220    @Test
221    public void isAssignmentCompatibleBytePrimitiveShort()
222    {
223        assertFalse( isAssignmentCompatible( byte.class, Short.class ) );
224        assertFalse( isAssignmentCompatible( byte.class, Short.TYPE ) );
225        assertFalse( isAssignmentCompatible( byte.class, short.class ) );
226    }
227
228    @Test
229    public void isAssignmentCompatibleBytePrimitiveInteger()
230    {
231        assertFalse( isAssignmentCompatible( byte.class, Integer.class ) );
232        assertFalse( isAssignmentCompatible( byte.class, Integer.TYPE ) );
233        assertFalse( isAssignmentCompatible( byte.class, int.class ) );
234    }
235
236    @Test
237    public void isAssignmentCompatibleBytePrimitiveLong()
238    {
239        assertFalse( isAssignmentCompatible( byte.class, Long.class ) );
240        assertFalse( isAssignmentCompatible( byte.class, Long.TYPE ) );
241        assertFalse( isAssignmentCompatible( byte.class, long.class ) );
242    }
243
244    @Test
245    public void isAssignmentCompatibleBytePrimitiveFloat()
246    {
247        assertFalse( isAssignmentCompatible( byte.class, Float.class ) );
248        assertFalse( isAssignmentCompatible( byte.class, Float.TYPE ) );
249        assertFalse( isAssignmentCompatible( byte.class, float.class ) );
250    }
251
252    @Test
253    public void isAssignmentCompatibleBytePrimitiveDouble()
254    {
255        assertFalse( isAssignmentCompatible( byte.class, Double.class ) );
256        assertFalse( isAssignmentCompatible( byte.class, Double.TYPE ) );
257        assertFalse( isAssignmentCompatible( byte.class, double.class ) );
258    }
259
260    @Test
261    public void isAssignmentCompatibleBytePrimitiveCharacter()
262    {
263        assertFalse( isAssignmentCompatible( byte.class, Character.class ) );
264        assertFalse( isAssignmentCompatible( byte.class, Character.TYPE ) );
265        assertFalse( isAssignmentCompatible( byte.class, char.class ) );
266    }
267
268    @Test
269    public void isAssignmentCompatibleBytePrimitiveString()
270    {
271        assertFalse( isAssignmentCompatible( byte.class, String.class ) );
272    }
273
274    @Test
275    public void isAssignmentCompatibleBytePrimitiveObject()
276    {
277        assertFalse( isAssignmentCompatible( byte.class, Object.class ) );
278    }
279
280    @Test
281    public void isAssignmentCompatibleBytePrimitveTestBean()
282    {
283        assertFalse( isAssignmentCompatible( byte.class, TestBean.class ) );
284    }
285
286    @Test
287    public void isAssignmentCompatibleByteWrapperBoolean()
288    {
289
290        assertFalse( isAssignmentCompatible( Byte.class, Boolean.class ) );
291        assertFalse( isAssignmentCompatible( Byte.class, boolean.class ) );
292        assertFalse( isAssignmentCompatible( Byte.class, Boolean.TYPE ) );
293    }
294
295    @Test
296    public void isAssignmentCompatibleByteWrapperByte()
297    {
298        assertTrue( isAssignmentCompatible( Byte.class, Byte.class ) );
299        assertFalse( isAssignmentCompatible( Byte.class, Byte.TYPE ) );
300        assertFalse( isAssignmentCompatible( Byte.class, byte.class ) );
301    }
302
303    @Test
304    public void isAssignmentCompatibleByteWrapperShort()
305    {
306        assertFalse( isAssignmentCompatible( Byte.class, Short.class ) );
307        assertFalse( isAssignmentCompatible( Byte.class, Short.TYPE ) );
308        assertFalse( isAssignmentCompatible( Byte.class, short.class ) );
309    }
310
311    @Test
312    public void isAssignmentCompatibleByteWrapperInteger()
313    {
314        assertFalse( isAssignmentCompatible( Byte.class, Integer.class ) );
315        assertFalse( isAssignmentCompatible( Byte.class, Integer.TYPE ) );
316        assertFalse( isAssignmentCompatible( Byte.class, int.class ) );
317    }
318
319    @Test
320    public void isAssignmentCompatibleByteWrapperLong()
321    {
322        assertFalse( isAssignmentCompatible( Byte.class, Long.class ) );
323        assertFalse( isAssignmentCompatible( Byte.class, Long.TYPE ) );
324        assertFalse( isAssignmentCompatible( Byte.class, long.class ) );
325    }
326
327    @Test
328    public void isAssignmentCompatibleByteWrapperFloat()
329    {
330        assertFalse( isAssignmentCompatible( Byte.class, Float.class ) );
331        assertFalse( isAssignmentCompatible( Byte.class, Float.TYPE ) );
332        assertFalse( isAssignmentCompatible( Byte.class, float.class ) );
333    }
334
335    @Test
336    public void isAssignmentCompatibleByteWrapperDouble()
337    {
338        assertFalse( isAssignmentCompatible( Byte.class, Double.class ) );
339        assertFalse( isAssignmentCompatible( Byte.class, Double.TYPE ) );
340        assertFalse( isAssignmentCompatible( Byte.class, double.class ) );
341    }
342
343    @Test
344    public void isAssignmentCompatibleByteWrapperCharacter()
345    {
346        assertFalse( isAssignmentCompatible( Byte.class, Character.class ) );
347        assertFalse( isAssignmentCompatible( Byte.class, Character.TYPE ) );
348        assertFalse( isAssignmentCompatible( Byte.class, char.class ) );
349    }
350
351    @Test
352    public void isAssignmentCompatibleByteWrapperString()
353    {
354        assertFalse( isAssignmentCompatible( Byte.class, String.class ) );
355    }
356
357    @Test
358    public void isAssignmentCompatibleByteWrapperObject()
359    {
360        assertFalse( isAssignmentCompatible( Byte.class, Object.class ) );
361    }
362
363    @Test
364    public void isAssignmentCompatibleByteWrapperTestBean()
365    {
366        assertFalse( isAssignmentCompatible( Byte.class, TestBean.class ) );
367    }
368
369    @Test
370    public void isAssignmentCompatibleShortPrimitiveBoolean()
371    {
372        assertFalse( isAssignmentCompatible( short.class, Boolean.class ) );
373        assertFalse( isAssignmentCompatible( short.class, Boolean.TYPE ) );
374        assertFalse( isAssignmentCompatible( short.class, Boolean.class ) );
375    }
376
377    @Test
378    public void isAssignmentCompatibleShortPrimitiveByte()
379    {
380        assertFalse( isAssignmentCompatible( short.class, Byte.class ) );
381        assertFalse( isAssignmentCompatible( short.class, Byte.TYPE ) );
382        assertFalse( isAssignmentCompatible( short.class, byte.class ) );
383    }
384
385    @Test
386    public void isAssignmentCompatibleShortPrimitiveShort()
387    {
388        assertTrue( isAssignmentCompatible( short.class, Short.class ) );
389        assertTrue( isAssignmentCompatible( short.class, Short.TYPE ) );
390        assertTrue( isAssignmentCompatible( short.class, short.class ) );
391    }
392
393    @Test
394    public void isAssignmentCompatibleShortPrimitiveInteger()
395    {
396        assertFalse( isAssignmentCompatible( short.class, Integer.class ) );
397        assertFalse( isAssignmentCompatible( short.class, Integer.TYPE ) );
398        assertFalse( isAssignmentCompatible( short.class, int.class ) );
399    }
400
401    @Test
402    public void isAssignmentCompatibleShortPrimitiveLong()
403    {
404        assertFalse( isAssignmentCompatible( short.class, Long.class ) );
405        assertFalse( isAssignmentCompatible( short.class, Long.TYPE ) );
406        assertFalse( isAssignmentCompatible( short.class, long.class ) );
407    }
408
409    @Test
410    public void isAssignmentCompatibleShortPrimitiveFloat()
411    {
412        assertFalse( isAssignmentCompatible( short.class, Float.class ) );
413        assertFalse( isAssignmentCompatible( short.class, Float.TYPE ) );
414        assertFalse( isAssignmentCompatible( short.class, float.class ) );
415    }
416
417    @Test
418    public void isAssignmentCompatibleShortPrimitiveDouble()
419    {
420        assertFalse( isAssignmentCompatible( short.class, Double.class ) );
421        assertFalse( isAssignmentCompatible( short.class, Double.TYPE ) );
422        assertFalse( isAssignmentCompatible( short.class, double.class ) );
423    }
424
425    @Test
426    public void isAssignmentCompatibleShortPrimitiveCharacter()
427    {
428        assertFalse( isAssignmentCompatible( short.class, Character.class ) );
429        assertFalse( isAssignmentCompatible( short.class, Character.TYPE ) );
430        assertFalse( isAssignmentCompatible( short.class, char.class ) );
431    }
432
433    @Test
434    public void isAssignmentCompatibleShortPrimitiveString()
435    {
436        assertFalse( isAssignmentCompatible( short.class, String.class ) );
437    }
438
439    @Test
440    public void isAssignmentCompatibleShortPrimitiveObject()
441    {
442        assertFalse( isAssignmentCompatible( short.class, Object.class ) );
443    }
444
445    @Test
446    public void isAssignmentCompatibleShortPrimitiveTestBean()
447    {
448        assertFalse( isAssignmentCompatible( short.class, TestBean.class ) );
449    }
450
451    @Test
452    public void isAssignmentCompatibleShortWrapperBoolean()
453    {
454
455        assertFalse( isAssignmentCompatible( Short.class, Boolean.class ) );
456        assertFalse( isAssignmentCompatible( Short.class, boolean.class ) );
457        assertFalse( isAssignmentCompatible( Short.class, Boolean.TYPE ) );
458    }
459
460    @Test
461    public void isAssignmentCompatibleShortWrapperByte()
462    {
463        assertFalse( isAssignmentCompatible( Short.class, Byte.class ) );
464        assertFalse( isAssignmentCompatible( Short.class, Byte.TYPE ) );
465        assertFalse( isAssignmentCompatible( Short.class, byte.class ) );
466    }
467
468    @Test
469    public void isAssignmentCompatibleShortWrapperShort()
470    {
471        assertTrue( isAssignmentCompatible( Short.class, Short.class ) );
472        assertFalse( isAssignmentCompatible( Short.class, Short.TYPE ) );
473        assertFalse( isAssignmentCompatible( Short.class, short.class ) );
474    }
475
476    @Test
477    public void isAssignmentCompatibleShortWrapperInteger()
478    {
479        assertFalse( isAssignmentCompatible( Short.class, Integer.class ) );
480        assertFalse( isAssignmentCompatible( Short.class, Integer.TYPE ) );
481        assertFalse( isAssignmentCompatible( Short.class, int.class ) );
482    }
483
484    @Test
485    public void isAssignmentCompatibleShortWrapperLong()
486    {
487        assertFalse( isAssignmentCompatible( Short.class, Long.class ) );
488        assertFalse( isAssignmentCompatible( Short.class, Long.TYPE ) );
489        assertFalse( isAssignmentCompatible( Short.class, long.class ) );
490    }
491
492    @Test
493    public void isAssignmentCompatibleShortWrapperFloat()
494    {
495        assertFalse( isAssignmentCompatible( Short.class, Float.class ) );
496        assertFalse( isAssignmentCompatible( Short.class, Float.TYPE ) );
497        assertFalse( isAssignmentCompatible( Short.class, float.class ) );
498    }
499
500    @Test
501    public void isAssignmentCompatibleShortWrapperDouble()
502    {
503        assertFalse( isAssignmentCompatible( Short.class, Double.class ) );
504        assertFalse( isAssignmentCompatible( Short.class, Double.TYPE ) );
505        assertFalse( isAssignmentCompatible( Short.class, double.class ) );
506    }
507
508    @Test
509    public void isAssignmentCompatibleShortWrapperCharacter()
510    {
511        assertFalse( isAssignmentCompatible( Short.class, Character.class ) );
512        assertFalse( isAssignmentCompatible( Short.class, Character.TYPE ) );
513        assertFalse( isAssignmentCompatible( Short.class, char.class ) );
514    }
515
516    @Test
517    public void isAssignmentCompatibleShortWrapperString()
518    {
519        assertFalse( isAssignmentCompatible( Short.class, String.class ) );
520    }
521
522    @Test
523    public void isAssignmentCompatibleShortWrapperObject()
524    {
525        assertFalse( isAssignmentCompatible( Short.class, Object.class ) );
526    }
527
528    @Test
529    public void isAssignmentCompatibleShortWrapperTestBean()
530    {
531        assertFalse( isAssignmentCompatible( Short.class, TestBean.class ) );
532    }
533
534    @Test
535    public void isAssignmentCompatibleIntegerPrimitiveBoolean()
536    {
537        assertFalse( isAssignmentCompatible( int.class, Boolean.class ) );
538        assertFalse( isAssignmentCompatible( int.class, Boolean.TYPE ) );
539        assertFalse( isAssignmentCompatible( int.class, Boolean.class ) );
540    }
541
542    @Test
543    public void isAssignmentCompatibleIntegerPrimitiveByte()
544    {
545        assertFalse( isAssignmentCompatible( int.class, Byte.class ) );
546        assertFalse( isAssignmentCompatible( int.class, Byte.TYPE ) );
547        assertFalse( isAssignmentCompatible( int.class, byte.class ) );
548    }
549
550    @Test
551    public void isAssignmentCompatibleIntegerPrimitiveShort()
552    {
553        assertFalse( isAssignmentCompatible( int.class, Short.class ) );
554        assertFalse( isAssignmentCompatible( int.class, Short.TYPE ) );
555        assertFalse( isAssignmentCompatible( int.class, short.class ) );
556    }
557
558    @Test
559    public void isAssignmentCompatibleIntegerPrimitiveInteger()
560    {
561        assertTrue( isAssignmentCompatible( int.class, Integer.class ) );
562        assertTrue( isAssignmentCompatible( int.class, Integer.TYPE ) );
563        assertTrue( isAssignmentCompatible( int.class, int.class ) );
564    }
565
566    @Test
567    public void isAssignmentCompatibleIntegerPrimitiveLong()
568    {
569        assertFalse( isAssignmentCompatible( int.class, Long.class ) );
570        assertFalse( isAssignmentCompatible( int.class, Long.TYPE ) );
571        assertFalse( isAssignmentCompatible( int.class, long.class ) );
572    }
573
574    @Test
575    public void isAssignmentCompatibleIntegerPrimitiveFloat()
576    {
577        assertFalse( isAssignmentCompatible( int.class, Float.class ) );
578        assertFalse( isAssignmentCompatible( int.class, Float.TYPE ) );
579        assertFalse( isAssignmentCompatible( int.class, float.class ) );
580    }
581
582    @Test
583    public void isAssignmentCompatibleIntegerPrimitiveDouble()
584    {
585        assertFalse( isAssignmentCompatible( int.class, Double.class ) );
586        assertFalse( isAssignmentCompatible( int.class, Double.TYPE ) );
587        assertFalse( isAssignmentCompatible( int.class, double.class ) );
588    }
589
590    @Test
591    public void isAssignmentCompatibleIntegerPrimitiveCharacter()
592    {
593        assertFalse( isAssignmentCompatible( int.class, Character.class ) );
594        assertFalse( isAssignmentCompatible( int.class, Character.TYPE ) );
595        assertFalse( isAssignmentCompatible( int.class, char.class ) );
596    }
597
598    @Test
599    public void isAssignmentCompatibleIntegerPrimitiveString()
600    {
601        assertFalse( isAssignmentCompatible( int.class, String.class ) );
602    }
603
604    @Test
605    public void isAssignmentCompatibleIntegerPrimitiveObject()
606    {
607        assertFalse( isAssignmentCompatible( int.class, Object.class ) );
608    }
609
610    @Test
611    public void isAssignmentCompatibleIntegerPrimitiveTestBean()
612    {
613        assertFalse( isAssignmentCompatible( int.class, TestBean.class ) );
614    }
615
616    @Test
617    public void isAssignmentCompatibleIntegerWrapperBoolean()
618    {
619
620        assertFalse( isAssignmentCompatible( Integer.class, Boolean.class ) );
621        assertFalse( isAssignmentCompatible( Integer.class, boolean.class ) );
622        assertFalse( isAssignmentCompatible( Integer.class, Boolean.TYPE ) );
623    }
624
625    @Test
626    public void isAssignmentCompatibleIntegerWrapperByte()
627    {
628        assertFalse( isAssignmentCompatible( Integer.class, Byte.class ) );
629        assertFalse( isAssignmentCompatible( Integer.class, Byte.TYPE ) );
630        assertFalse( isAssignmentCompatible( Integer.class, byte.class ) );
631    }
632
633    @Test
634    public void isAssignmentCompatibleIntegerWrapperShort()
635    {
636        assertFalse( isAssignmentCompatible( Integer.class, Short.class ) );
637        assertFalse( isAssignmentCompatible( Integer.class, Short.TYPE ) );
638        assertFalse( isAssignmentCompatible( Integer.class, short.class ) );
639    }
640
641    @Test
642    public void isAssignmentCompatibleIntegerWrapperInteger()
643    {
644        assertTrue( isAssignmentCompatible( Integer.class, Integer.class ) );
645        assertFalse( isAssignmentCompatible( Integer.class, Integer.TYPE ) );
646        assertFalse( isAssignmentCompatible( Integer.class, int.class ) );
647    }
648
649    @Test
650    public void isAssignmentCompatibleIntegerWrapperLong()
651    {
652        assertFalse( isAssignmentCompatible( Integer.class, Long.class ) );
653        assertFalse( isAssignmentCompatible( Integer.class, Long.TYPE ) );
654        assertFalse( isAssignmentCompatible( Integer.class, long.class ) );
655    }
656
657    @Test
658    public void isAssignmentCompatibleIntegerWrapperFloat()
659    {
660        assertFalse( isAssignmentCompatible( Integer.class, Float.class ) );
661        assertFalse( isAssignmentCompatible( Integer.class, Float.TYPE ) );
662        assertFalse( isAssignmentCompatible( Integer.class, float.class ) );
663    }
664
665    @Test
666    public void isAssignmentCompatibleIntegerWrapperDouble()
667    {
668        assertFalse( isAssignmentCompatible( Integer.class, Double.class ) );
669        assertFalse( isAssignmentCompatible( Integer.class, Double.TYPE ) );
670        assertFalse( isAssignmentCompatible( Integer.class, double.class ) );
671    }
672
673    @Test
674    public void isAssignmentCompatibleIntegerWrapperCharacter()
675    {
676        assertFalse( isAssignmentCompatible( Integer.class, Character.class ) );
677        assertFalse( isAssignmentCompatible( Integer.class, Character.TYPE ) );
678        assertFalse( isAssignmentCompatible( Integer.class, char.class ) );
679    }
680
681    @Test
682    public void isAssignmentCompatibleIntegerWrapperString()
683    {
684        assertFalse( isAssignmentCompatible( Integer.class, String.class ) );
685    }
686
687    @Test
688    public void isAssignmentCompatibleIntegerWrapperObject()
689    {
690        assertFalse( isAssignmentCompatible( Integer.class, Object.class ) );
691    }
692
693    @Test
694    public void isAssignmentCompatibleIntegerWrapperTestBean()
695    {
696        assertFalse( isAssignmentCompatible( Integer.class, TestBean.class ) );
697    }
698
699    @Test
700    public void isAssignmentCompatibleLongPrimitiveBoolean()
701    {
702        assertFalse( isAssignmentCompatible( long.class, Boolean.class ) );
703        assertFalse( isAssignmentCompatible( long.class, Boolean.TYPE ) );
704        assertFalse( isAssignmentCompatible( long.class, Boolean.class ) );
705    }
706
707    @Test
708    public void isAssignmentCompatibleLongPrimitiveByte()
709    {
710        assertFalse( isAssignmentCompatible( long.class, Byte.class ) );
711        assertFalse( isAssignmentCompatible( long.class, Byte.TYPE ) );
712        assertFalse( isAssignmentCompatible( long.class, byte.class ) );
713    }
714
715    @Test
716    public void isAssignmentCompatibleLongPrimitiveShort()
717    {
718        assertFalse( isAssignmentCompatible( long.class, Short.class ) );
719        assertFalse( isAssignmentCompatible( long.class, Short.TYPE ) );
720        assertFalse( isAssignmentCompatible( long.class, short.class ) );
721    }
722
723    @Test
724    public void isAssignmentCompatibleLongPrimitiveInteger()
725    {
726        assertFalse( isAssignmentCompatible( long.class, Integer.class ) );
727        assertFalse( isAssignmentCompatible( long.class, Integer.TYPE ) );
728        assertFalse( isAssignmentCompatible( long.class, int.class ) );
729    }
730
731    @Test
732    public void isAssignmentCompatibleLongPrimitiveLong()
733    {
734        assertTrue( isAssignmentCompatible( long.class, Long.class ) );
735        assertTrue( isAssignmentCompatible( long.class, Long.TYPE ) );
736        assertTrue( isAssignmentCompatible( long.class, long.class ) );
737    }
738
739    @Test
740    public void isAssignmentCompatibleLongPrimitiveFloat()
741    {
742        assertFalse( isAssignmentCompatible( long.class, Float.class ) );
743        assertFalse( isAssignmentCompatible( long.class, Float.TYPE ) );
744        assertFalse( isAssignmentCompatible( long.class, float.class ) );
745    }
746
747    @Test
748    public void isAssignmentCompatibleLongPrimitiveDouble()
749    {
750        assertFalse( isAssignmentCompatible( long.class, Double.class ) );
751        assertFalse( isAssignmentCompatible( long.class, Double.TYPE ) );
752        assertFalse( isAssignmentCompatible( long.class, double.class ) );
753    }
754
755    @Test
756    public void isAssignmentCompatibleLongPrimitiveCharacter()
757    {
758        assertFalse( isAssignmentCompatible( long.class, Character.class ) );
759        assertFalse( isAssignmentCompatible( long.class, Character.TYPE ) );
760        assertFalse( isAssignmentCompatible( long.class, char.class ) );
761    }
762
763    @Test
764    public void isAssignmentCompatibleLongPrimitiveString()
765    {
766        assertFalse( isAssignmentCompatible( long.class, String.class ) );
767    }
768
769    @Test
770    public void isAssignmentCompatibleLongPrimitiveObject()
771    {
772        assertFalse( isAssignmentCompatible( long.class, Object.class ) );
773    }
774
775    @Test
776    public void isAssignmentCompatibleLongPrimitiveTestBean()
777    {
778        assertFalse( isAssignmentCompatible( long.class, TestBean.class ) );
779    }
780
781    @Test
782    public void isAssignmentCompatibleLongWrapperBoolean()
783    {
784
785        assertFalse( isAssignmentCompatible( Long.class, Boolean.class ) );
786        assertFalse( isAssignmentCompatible( Long.class, boolean.class ) );
787        assertFalse( isAssignmentCompatible( Long.class, Boolean.TYPE ) );
788    }
789
790    @Test
791    public void isAssignmentCompatibleLongWrapperByte()
792    {
793        assertFalse( isAssignmentCompatible( Long.class, Byte.class ) );
794        assertFalse( isAssignmentCompatible( Long.class, Byte.TYPE ) );
795        assertFalse( isAssignmentCompatible( Long.class, byte.class ) );
796    }
797
798    @Test
799    public void isAssignmentCompatibleLongWrapperShort()
800    {
801        assertFalse( isAssignmentCompatible( Long.class, Short.class ) );
802        assertFalse( isAssignmentCompatible( Long.class, Short.TYPE ) );
803        assertFalse( isAssignmentCompatible( Long.class, short.class ) );
804    }
805
806    @Test
807    public void isAssignmentCompatibleLongWrapperInteger()
808    {
809        assertFalse( isAssignmentCompatible( Long.class, Integer.class ) );
810        assertFalse( isAssignmentCompatible( Long.class, Integer.TYPE ) );
811        assertFalse( isAssignmentCompatible( Long.class, int.class ) );
812    }
813
814    @Test
815    public void isAssignmentCompatibleLongWrapperLong()
816    {
817        assertTrue( isAssignmentCompatible( Long.class, Long.class ) );
818        assertFalse( isAssignmentCompatible( Long.class, Long.TYPE ) );
819        assertFalse( isAssignmentCompatible( Long.class, long.class ) );
820    }
821
822    @Test
823    public void isAssignmentCompatibleLongWrapperFloat()
824    {
825        assertFalse( isAssignmentCompatible( Long.class, Float.class ) );
826        assertFalse( isAssignmentCompatible( Long.class, Float.TYPE ) );
827        assertFalse( isAssignmentCompatible( Long.class, float.class ) );
828    }
829
830    @Test
831    public void isAssignmentCompatibleLongWrapperDouble()
832    {
833        assertFalse( isAssignmentCompatible( Long.class, Double.class ) );
834        assertFalse( isAssignmentCompatible( Long.class, Double.TYPE ) );
835        assertFalse( isAssignmentCompatible( Long.class, double.class ) );
836    }
837
838    @Test
839    public void isAssignmentCompatibleLongWrapperCharacter()
840    {
841        assertFalse( isAssignmentCompatible( Long.class, Character.class ) );
842        assertFalse( isAssignmentCompatible( Long.class, Character.TYPE ) );
843        assertFalse( isAssignmentCompatible( Long.class, char.class ) );
844    }
845
846    @Test
847    public void isAssignmentCompatibleLongWrapperString()
848    {
849        assertFalse( isAssignmentCompatible( Long.class, String.class ) );
850    }
851
852    @Test
853    public void isAssignmentCompatibleLongWrapperObject()
854    {
855        assertFalse( isAssignmentCompatible( Long.class, Object.class ) );
856    }
857
858    @Test
859    public void isAssignmentCompatibleLongWrapperTestBean()
860    {
861        assertFalse( isAssignmentCompatible( Long.class, TestBean.class ) );
862    }
863
864    @Test
865    public void isAssignmentCompatibleFloatPrimitiveBoolean()
866    {
867        assertFalse( isAssignmentCompatible( float.class, Boolean.class ) );
868        assertFalse( isAssignmentCompatible( float.class, Boolean.TYPE ) );
869        assertFalse( isAssignmentCompatible( float.class, Boolean.class ) );
870    }
871
872    @Test
873    public void isAssignmentCompatibleFloatPrimitiveByte()
874    {
875        assertFalse( isAssignmentCompatible( float.class, Byte.class ) );
876        assertFalse( isAssignmentCompatible( float.class, Byte.TYPE ) );
877        assertFalse( isAssignmentCompatible( float.class, byte.class ) );
878    }
879
880    @Test
881    public void isAssignmentCompatibleFloatPrimitiveShort()
882    {
883        assertFalse( isAssignmentCompatible( float.class, Short.class ) );
884        assertFalse( isAssignmentCompatible( float.class, Short.TYPE ) );
885        assertFalse( isAssignmentCompatible( float.class, short.class ) );
886    }
887
888    @Test
889    public void isAssignmentCompatibleFloatPrimitiveInteger()
890    {
891        assertFalse( isAssignmentCompatible( float.class, Integer.class ) );
892        assertFalse( isAssignmentCompatible( float.class, Integer.TYPE ) );
893        assertFalse( isAssignmentCompatible( float.class, int.class ) );
894    }
895
896    @Test
897    public void isAssignmentCompatibleFloatPrimitiveLong()
898    {
899        assertFalse( isAssignmentCompatible( float.class, Long.class ) );
900        assertFalse( isAssignmentCompatible( float.class, Long.TYPE ) );
901        assertFalse( isAssignmentCompatible( float.class, long.class ) );
902    }
903
904    @Test
905    public void isAssignmentCompatibleFloatPrimitiveFloat()
906    {
907        assertTrue( isAssignmentCompatible( float.class, Float.class ) );
908        assertTrue( isAssignmentCompatible( float.class, Float.TYPE ) );
909        assertTrue( isAssignmentCompatible( float.class, float.class ) );
910    }
911
912    @Test
913    public void isAssignmentCompatibleFloatPrimitiveDouble()
914    {
915        assertFalse( isAssignmentCompatible( float.class, Double.class ) );
916        assertFalse( isAssignmentCompatible( float.class, Double.TYPE ) );
917        assertFalse( isAssignmentCompatible( float.class, double.class ) );
918    }
919
920    @Test
921    public void isAssignmentCompatibleFloatPrimitiveCharacter()
922    {
923        assertFalse( isAssignmentCompatible( float.class, Character.class ) );
924        assertFalse( isAssignmentCompatible( float.class, Character.TYPE ) );
925        assertFalse( isAssignmentCompatible( float.class, char.class ) );
926    }
927
928    @Test
929    public void isAssignmentCompatibleFloatPrimitiveString()
930    {
931        assertFalse( isAssignmentCompatible( float.class, String.class ) );
932    }
933
934    @Test
935    public void isAssignmentCompatibleFloatPrimitiveObject()
936    {
937        assertFalse( isAssignmentCompatible( float.class, Object.class ) );
938    }
939
940    @Test
941    public void isAssignmentCompatibleFloatPrimitiveTestBean()
942    {
943        assertFalse( isAssignmentCompatible( float.class, TestBean.class ) );
944    }
945
946    @Test
947    public void isAssignmentCompatibleFloatWrapperBoolean()
948    {
949
950        assertFalse( isAssignmentCompatible( Float.class, Boolean.class ) );
951        assertFalse( isAssignmentCompatible( Float.class, boolean.class ) );
952        assertFalse( isAssignmentCompatible( Float.class, Boolean.TYPE ) );
953    }
954
955    @Test
956    public void isAssignmentCompatibleFloatWrapperByte()
957    {
958        assertFalse( isAssignmentCompatible( Float.class, Byte.class ) );
959        assertFalse( isAssignmentCompatible( Float.class, Byte.TYPE ) );
960        assertFalse( isAssignmentCompatible( Float.class, byte.class ) );
961    }
962
963    @Test
964    public void isAssignmentCompatibleFloatWrapperShort()
965    {
966        assertFalse( isAssignmentCompatible( Float.class, Short.class ) );
967        assertFalse( isAssignmentCompatible( Float.class, Short.TYPE ) );
968        assertFalse( isAssignmentCompatible( Float.class, short.class ) );
969    }
970
971    @Test
972    public void isAssignmentCompatibleFloatWrapperInteger()
973    {
974        assertFalse( isAssignmentCompatible( Float.class, Integer.class ) );
975        assertFalse( isAssignmentCompatible( Float.class, Integer.TYPE ) );
976        assertFalse( isAssignmentCompatible( Float.class, int.class ) );
977    }
978
979    @Test
980    public void isAssignmentCompatibleFloatWrapperLong()
981    {
982        assertFalse( isAssignmentCompatible( Float.class, Long.class ) );
983        assertFalse( isAssignmentCompatible( Float.class, Long.TYPE ) );
984        assertFalse( isAssignmentCompatible( Float.class, long.class ) );
985    }
986
987    @Test
988    public void isAssignmentCompatibleFloatWrapperFloat()
989    {
990        assertTrue( isAssignmentCompatible( Float.class, Float.class ) );
991        assertFalse( isAssignmentCompatible( Float.class, Float.TYPE ) );
992        assertFalse( isAssignmentCompatible( Float.class, float.class ) );
993    }
994
995    @Test
996    public void isAssignmentCompatibleFloatWrapperDouble()
997    {
998        assertFalse( isAssignmentCompatible( Float.class, Double.class ) );
999        assertFalse( isAssignmentCompatible( Float.class, Double.TYPE ) );
1000        assertFalse( isAssignmentCompatible( Float.class, double.class ) );
1001    }
1002
1003    @Test
1004    public void isAssignmentCompatibleFloatWrapperCharacter()
1005    {
1006        assertFalse( isAssignmentCompatible( Float.class, Character.class ) );
1007        assertFalse( isAssignmentCompatible( Float.class, Character.TYPE ) );
1008        assertFalse( isAssignmentCompatible( Float.class, char.class ) );
1009    }
1010
1011    @Test
1012    public void isAssignmentCompatibleFloatWrapperString()
1013    {
1014        assertFalse( isAssignmentCompatible( Float.class, String.class ) );
1015    }
1016
1017    @Test
1018    public void isAssignmentCompatibleFloatWrapperObject()
1019    {
1020        assertFalse( isAssignmentCompatible( Float.class, Object.class ) );
1021    }
1022
1023    @Test
1024    public void isAssignmentCompatibleFloatWrapperTestBean()
1025    {
1026        assertFalse( isAssignmentCompatible( Float.class, TestBean.class ) );
1027    }
1028
1029    @Test
1030    public void isAssignmentCompatibleDoublePrimitiveBoolean()
1031    {
1032        assertFalse( isAssignmentCompatible( double.class, Boolean.class ) );
1033        assertFalse( isAssignmentCompatible( double.class, Boolean.TYPE ) );
1034        assertFalse( isAssignmentCompatible( double.class, Boolean.class ) );
1035    }
1036
1037    @Test
1038    public void isAssignmentCompatibleDoublePrimitiveByte()
1039    {
1040        assertFalse( isAssignmentCompatible( double.class, Byte.class ) );
1041        assertFalse( isAssignmentCompatible( double.class, Byte.TYPE ) );
1042        assertFalse( isAssignmentCompatible( double.class, byte.class ) );
1043    }
1044
1045    @Test
1046    public void isAssignmentCompatibleDoublePrimitiveShort()
1047    {
1048        assertFalse( isAssignmentCompatible( double.class, Short.class ) );
1049        assertFalse( isAssignmentCompatible( double.class, Short.TYPE ) );
1050        assertFalse( isAssignmentCompatible( double.class, short.class ) );
1051    }
1052
1053    @Test
1054    public void isAssignmentCompatibleDoublePrimitiveInteger()
1055    {
1056        assertFalse( isAssignmentCompatible( double.class, Integer.class ) );
1057        assertFalse( isAssignmentCompatible( double.class, Integer.TYPE ) );
1058        assertFalse( isAssignmentCompatible( double.class, int.class ) );
1059    }
1060
1061    @Test
1062    public void isAssignmentCompatibleDoublePrimitiveLong()
1063    {
1064        assertFalse( isAssignmentCompatible( double.class, Long.class ) );
1065        assertFalse( isAssignmentCompatible( double.class, Long.TYPE ) );
1066        assertFalse( isAssignmentCompatible( double.class, long.class ) );
1067    }
1068
1069    @Test
1070    public void isAssignmentCompatibleDoublePrimitiveFloat()
1071    {
1072        assertFalse( isAssignmentCompatible( double.class, Float.class ) );
1073        assertFalse( isAssignmentCompatible( double.class, Float.TYPE ) );
1074        assertFalse( isAssignmentCompatible( double.class, float.class ) );
1075    }
1076
1077    @Test
1078    public void isAssignmentCompatibleDoublePrimitiveDouble()
1079    {
1080        assertTrue( isAssignmentCompatible( double.class, Double.class ) );
1081        assertTrue( isAssignmentCompatible( double.class, Double.TYPE ) );
1082        assertTrue( isAssignmentCompatible( double.class, double.class ) );
1083    }
1084
1085    @Test
1086    public void isAssignmentCompatibleDoublePrimitiveCharacter()
1087    {
1088        assertFalse( isAssignmentCompatible( double.class, Character.class ) );
1089        assertFalse( isAssignmentCompatible( double.class, Character.TYPE ) );
1090        assertFalse( isAssignmentCompatible( double.class, char.class ) );
1091    }
1092
1093    @Test
1094    public void isAssignmentCompatibleDoublePrimitiveString()
1095    {
1096        assertFalse( isAssignmentCompatible( double.class, String.class ) );
1097    }
1098
1099    @Test
1100    public void isAssignmentCompatibleDoublePrimitiveObject()
1101    {
1102        assertFalse( isAssignmentCompatible( double.class, Object.class ) );
1103    }
1104
1105    @Test
1106    public void isAssignmentCompatibleDoublePrimitiveTestBean()
1107    {
1108        assertFalse( isAssignmentCompatible( double.class, TestBean.class ) );
1109    }
1110
1111    @Test
1112    public void isAssignmentCompatibleDoubleWrapperBoolean()
1113    {
1114
1115        assertFalse( isAssignmentCompatible( Double.class, Boolean.class ) );
1116        assertFalse( isAssignmentCompatible( Double.class, boolean.class ) );
1117        assertFalse( isAssignmentCompatible( Double.class, Boolean.TYPE ) );
1118    }
1119
1120    @Test
1121    public void isAssignmentCompatibleDoubleWrapperByte()
1122    {
1123        assertFalse( isAssignmentCompatible( Double.class, Byte.class ) );
1124        assertFalse( isAssignmentCompatible( Double.class, Byte.TYPE ) );
1125        assertFalse( isAssignmentCompatible( Double.class, byte.class ) );
1126    }
1127
1128    @Test
1129    public void isAssignmentCompatibleDoubleWrapperShort()
1130    {
1131        assertFalse( isAssignmentCompatible( Double.class, Short.class ) );
1132        assertFalse( isAssignmentCompatible( Double.class, Short.TYPE ) );
1133        assertFalse( isAssignmentCompatible( Double.class, short.class ) );
1134    }
1135
1136    @Test
1137    public void isAssignmentCompatibleDoubleWrapperInteger()
1138    {
1139        assertFalse( isAssignmentCompatible( Double.class, Integer.class ) );
1140        assertFalse( isAssignmentCompatible( Double.class, Integer.TYPE ) );
1141        assertFalse( isAssignmentCompatible( Double.class, int.class ) );
1142    }
1143
1144    @Test
1145    public void isAssignmentCompatibleDoubleWrapperLong()
1146    {
1147        assertFalse( isAssignmentCompatible( Double.class, Long.class ) );
1148        assertFalse( isAssignmentCompatible( Double.class, Long.TYPE ) );
1149        assertFalse( isAssignmentCompatible( Double.class, long.class ) );
1150    }
1151
1152    @Test
1153    public void isAssignmentCompatibleDoubleWrapperFloat()
1154    {
1155        assertFalse( isAssignmentCompatible( Double.class, Float.class ) );
1156        assertFalse( isAssignmentCompatible( Double.class, Float.TYPE ) );
1157        assertFalse( isAssignmentCompatible( Double.class, float.class ) );
1158    }
1159
1160    @Test
1161    public void isAssignmentCompatibleDoubleWrapperDouble()
1162    {
1163        assertTrue( isAssignmentCompatible( Double.class, Double.class ) );
1164        assertFalse( isAssignmentCompatible( Double.class, Double.TYPE ) );
1165        assertFalse( isAssignmentCompatible( Double.class, double.class ) );
1166    }
1167
1168    @Test
1169    public void isAssignmentCompatibleDoubleWrapperCharacter()
1170    {
1171        assertFalse( isAssignmentCompatible( Double.class, Character.class ) );
1172        assertFalse( isAssignmentCompatible( Double.class, Character.TYPE ) );
1173        assertFalse( isAssignmentCompatible( Double.class, char.class ) );
1174    }
1175
1176    @Test
1177    public void isAssignmentCompatibleDoubleWrapperString()
1178    {
1179        assertFalse( isAssignmentCompatible( Double.class, String.class ) );
1180    }
1181
1182    @Test
1183    public void isAssignmentCompatibleDoubleWrapperObject()
1184    {
1185        assertFalse( isAssignmentCompatible( Double.class, Object.class ) );
1186    }
1187
1188    @Test
1189    public void isAssignmentCompatibleDoubleWrapperTestBean()
1190    {
1191        assertFalse( isAssignmentCompatible( Double.class, TestBean.class ) );
1192    }
1193
1194    @Test
1195    public void isAssignmentCompatibleCharacterPrimitiveBoolean()
1196    {
1197        assertFalse( isAssignmentCompatible( char.class, Boolean.class ) );
1198        assertFalse( isAssignmentCompatible( char.class, Boolean.TYPE ) );
1199        assertFalse( isAssignmentCompatible( char.class, Boolean.class ) );
1200    }
1201
1202    @Test
1203    public void isAssignmentCompatibleCharacterPrimitiveByte()
1204    {
1205        assertFalse( isAssignmentCompatible( char.class, Byte.class ) );
1206        assertFalse( isAssignmentCompatible( char.class, Byte.TYPE ) );
1207        assertFalse( isAssignmentCompatible( char.class, byte.class ) );
1208    }
1209
1210    @Test
1211    public void isAssignmentCompatibleCharacterPrimitiveShort()
1212    {
1213        assertFalse( isAssignmentCompatible( char.class, Short.class ) );
1214        assertFalse( isAssignmentCompatible( char.class, Short.TYPE ) );
1215        assertFalse( isAssignmentCompatible( char.class, short.class ) );
1216    }
1217
1218    @Test
1219    public void isAssignmentCompatibleCharacterPrimitiveInteger()
1220    {
1221        assertFalse( isAssignmentCompatible( char.class, Integer.class ) );
1222        assertFalse( isAssignmentCompatible( char.class, Integer.TYPE ) );
1223        assertFalse( isAssignmentCompatible( char.class, int.class ) );
1224    }
1225
1226    @Test
1227    public void isAssignmentCompatibleCharacterPrimitiveLong()
1228    {
1229        assertFalse( isAssignmentCompatible( char.class, Long.class ) );
1230        assertFalse( isAssignmentCompatible( char.class, Long.TYPE ) );
1231        assertFalse( isAssignmentCompatible( char.class, long.class ) );
1232    }
1233
1234    @Test
1235    public void isAssignmentCompatibleCharacterPrimitiveFloat()
1236    {
1237        assertFalse( isAssignmentCompatible( char.class, Float.class ) );
1238        assertFalse( isAssignmentCompatible( char.class, Float.TYPE ) );
1239        assertFalse( isAssignmentCompatible( char.class, float.class ) );
1240    }
1241
1242    @Test
1243    public void isAssignmentCompatibleCharacterPrimitiveDouble()
1244    {
1245        assertFalse( isAssignmentCompatible( char.class, Double.class ) );
1246        assertFalse( isAssignmentCompatible( char.class, Double.TYPE ) );
1247        assertFalse( isAssignmentCompatible( char.class, double.class ) );
1248    }
1249
1250    @Test
1251    public void isAssignmentCompatibleCharacterPrimitiveCharacter()
1252    {
1253        assertTrue( isAssignmentCompatible( char.class, Character.class ) );
1254        assertTrue( isAssignmentCompatible( char.class, Character.TYPE ) );
1255        assertTrue( isAssignmentCompatible( char.class, char.class ) );
1256    }
1257
1258    @Test
1259    public void isAssignmentCompatibleCharacterPrimitiveString()
1260    {
1261        assertFalse( isAssignmentCompatible( char.class, String.class ) );
1262    }
1263
1264    @Test
1265    public void isAssignmentCompatibleCharacterPrimitiveObject()
1266    {
1267        assertFalse( isAssignmentCompatible( char.class, Object.class ) );
1268    }
1269
1270    @Test
1271    public void isAssignmentCompatibleCharacterPrimitiveTestBean()
1272    {
1273        assertFalse( isAssignmentCompatible( char.class, TestBean.class ) );
1274    }
1275
1276    @Test
1277    public void isAssignmentCompatibleCharacterWrapperBoolean()
1278    {
1279
1280        assertFalse( isAssignmentCompatible( Character.class, Boolean.class ) );
1281        assertFalse( isAssignmentCompatible( Character.class, boolean.class ) );
1282        assertFalse( isAssignmentCompatible( Character.class, Boolean.TYPE ) );
1283    }
1284
1285    @Test
1286    public void isAssignmentCompatibleCharacterWrapperByte()
1287    {
1288        assertFalse( isAssignmentCompatible( Character.class, Byte.class ) );
1289        assertFalse( isAssignmentCompatible( Character.class, Byte.TYPE ) );
1290        assertFalse( isAssignmentCompatible( Character.class, byte.class ) );
1291    }
1292
1293    @Test
1294    public void isAssignmentCompatibleCharacterWrapperShort()
1295    {
1296        assertFalse( isAssignmentCompatible( Character.class, Short.class ) );
1297        assertFalse( isAssignmentCompatible( Character.class, Short.TYPE ) );
1298        assertFalse( isAssignmentCompatible( Character.class, short.class ) );
1299    }
1300
1301    @Test
1302    public void isAssignmentCompatibleCharacterWrapperInteger()
1303    {
1304        assertFalse( isAssignmentCompatible( Character.class, Integer.class ) );
1305        assertFalse( isAssignmentCompatible( Character.class, Integer.TYPE ) );
1306        assertFalse( isAssignmentCompatible( Character.class, int.class ) );
1307    }
1308
1309    @Test
1310    public void isAssignmentCompatibleCharacterWrapperLong()
1311    {
1312        assertFalse( isAssignmentCompatible( Character.class, Long.class ) );
1313        assertFalse( isAssignmentCompatible( Character.class, Long.TYPE ) );
1314        assertFalse( isAssignmentCompatible( Character.class, long.class ) );
1315    }
1316
1317    @Test
1318    public void isAssignmentCompatibleCharacterWrapperFloat()
1319    {
1320        assertFalse( isAssignmentCompatible( Character.class, Float.class ) );
1321        assertFalse( isAssignmentCompatible( Character.class, Float.TYPE ) );
1322        assertFalse( isAssignmentCompatible( Character.class, float.class ) );
1323    }
1324
1325    @Test
1326    public void isAssignmentCompatibleCharacterWrapperDouble()
1327    {
1328        assertFalse( isAssignmentCompatible( Character.class, Double.class ) );
1329        assertFalse( isAssignmentCompatible( Character.class, Double.TYPE ) );
1330        assertFalse( isAssignmentCompatible( Character.class, double.class ) );
1331    }
1332
1333    @Test
1334    public void isAssignmentCompatibleCharacterWrapperCharacter()
1335    {
1336        assertTrue( isAssignmentCompatible( Character.class, Character.class ) );
1337        assertFalse( isAssignmentCompatible( Character.class, Character.TYPE ) );
1338        assertFalse( isAssignmentCompatible( Character.class, char.class ) );
1339    }
1340
1341    @Test
1342    public void isAssignmentCompatibleCharacterWrapperString()
1343    {
1344        assertFalse( isAssignmentCompatible( Character.class, String.class ) );
1345    }
1346
1347    @Test
1348    public void isAssignmentCompatibleCharacterWrapperObject()
1349    {
1350        assertFalse( isAssignmentCompatible( Character.class, Object.class ) );
1351    }
1352
1353    @Test
1354    public void isAssignmentCompatibleCharacterWrapperTestBean()
1355    {
1356        assertFalse( isAssignmentCompatible( Character.class, TestBean.class ) );
1357    }
1358
1359    @Test
1360    public void isAssignmentCompatibleStringBoolean()
1361    {
1362
1363        assertFalse( isAssignmentCompatible( String.class, Boolean.class ) );
1364        assertFalse( isAssignmentCompatible( String.class, boolean.class ) );
1365        assertFalse( isAssignmentCompatible( String.class, Boolean.TYPE ) );
1366    }
1367
1368    @Test
1369    public void isAssignmentCompatibleStringByte()
1370    {
1371        assertFalse( isAssignmentCompatible( String.class, Byte.class ) );
1372        assertFalse( isAssignmentCompatible( String.class, Byte.TYPE ) );
1373        assertFalse( isAssignmentCompatible( String.class, byte.class ) );
1374    }
1375
1376    @Test
1377    public void isAssignmentCompatibleStringShort()
1378    {
1379        assertFalse( isAssignmentCompatible( String.class, Short.class ) );
1380        assertFalse( isAssignmentCompatible( String.class, Short.TYPE ) );
1381        assertFalse( isAssignmentCompatible( String.class, short.class ) );
1382    }
1383
1384    @Test
1385    public void isAssignmentCompatibleStringInteger()
1386    {
1387        assertFalse( isAssignmentCompatible( String.class, Integer.class ) );
1388        assertFalse( isAssignmentCompatible( String.class, Integer.TYPE ) );
1389        assertFalse( isAssignmentCompatible( String.class, int.class ) );
1390    }
1391
1392    @Test
1393    public void isAssignmentCompatibleStringLong()
1394    {
1395        assertFalse( isAssignmentCompatible( String.class, Long.class ) );
1396        assertFalse( isAssignmentCompatible( String.class, Long.TYPE ) );
1397        assertFalse( isAssignmentCompatible( String.class, long.class ) );
1398    }
1399
1400    @Test
1401    public void isAssignmentCompatibleStringFloat()
1402    {
1403        assertFalse( isAssignmentCompatible( String.class, Float.class ) );
1404        assertFalse( isAssignmentCompatible( String.class, Float.TYPE ) );
1405        assertFalse( isAssignmentCompatible( String.class, float.class ) );
1406    }
1407
1408    @Test
1409    public void isAssignmentCompatibleStringDouble()
1410    {
1411        assertFalse( isAssignmentCompatible( String.class, Double.class ) );
1412        assertFalse( isAssignmentCompatible( String.class, Double.TYPE ) );
1413        assertFalse( isAssignmentCompatible( String.class, double.class ) );
1414    }
1415
1416    @Test
1417    public void isAssignmentCompatibleStringCharacter()
1418    {
1419        assertFalse( isAssignmentCompatible( String.class, Character.class ) );
1420        assertFalse( isAssignmentCompatible( String.class, Character.TYPE ) );
1421        assertFalse( isAssignmentCompatible( String.class, char.class ) );
1422    }
1423
1424    @Test
1425    public void isAssignmentCompatibleStringString()
1426    {
1427        assertTrue( isAssignmentCompatible( String.class, String.class ) );
1428    }
1429
1430    @Test
1431    public void isAssignmentCompatibleStringObject()
1432    {
1433        assertFalse( isAssignmentCompatible( String.class, Object.class ) );
1434    }
1435
1436    @Test
1437    public void isAssignmentCompatibleStringTestBean()
1438    {
1439        assertFalse( isAssignmentCompatible( String.class, TestBean.class ) );
1440    }
1441
1442    @Test
1443    public void isAssignmentCompatibleObjectBoolean()
1444    {
1445
1446        assertTrue( isAssignmentCompatible( Object.class, Boolean.class ) );
1447        assertFalse( isAssignmentCompatible( Object.class, boolean.class ) );
1448        assertFalse( isAssignmentCompatible( Object.class, Boolean.TYPE ) );
1449    }
1450
1451    @Test
1452    public void isAssignmentCompatibleObjectByte()
1453    {
1454        assertTrue( isAssignmentCompatible( Object.class, Byte.class ) );
1455        assertFalse( isAssignmentCompatible( Object.class, Byte.TYPE ) );
1456        assertFalse( isAssignmentCompatible( Object.class, byte.class ) );
1457    }
1458
1459    @Test
1460    public void isAssignmentCompatibleObjectShort()
1461    {
1462        assertTrue( isAssignmentCompatible( Object.class, Short.class ) );
1463        assertFalse( isAssignmentCompatible( Object.class, Short.TYPE ) );
1464        assertFalse( isAssignmentCompatible( Object.class, short.class ) );
1465    }
1466
1467    @Test
1468    public void isAssignmentCompatibleObjectInteger()
1469    {
1470        assertTrue( isAssignmentCompatible( Object.class, Integer.class ) );
1471        assertFalse( isAssignmentCompatible( Object.class, Integer.TYPE ) );
1472        assertFalse( isAssignmentCompatible( Object.class, int.class ) );
1473    }
1474
1475    @Test
1476    public void isAssignmentCompatibleObjectLong()
1477    {
1478        assertTrue( isAssignmentCompatible( Object.class, Long.class ) );
1479        assertFalse( isAssignmentCompatible( Object.class, Long.TYPE ) );
1480        assertFalse( isAssignmentCompatible( Object.class, long.class ) );
1481    }
1482
1483    @Test
1484    public void isAssignmentCompatibleObjectFloat()
1485    {
1486        assertTrue( isAssignmentCompatible( Object.class, Float.class ) );
1487        assertFalse( isAssignmentCompatible( Object.class, Float.TYPE ) );
1488        assertFalse( isAssignmentCompatible( Object.class, float.class ) );
1489    }
1490
1491    @Test
1492    public void isAssignmentCompatibleObjectDouble()
1493    {
1494        assertTrue( isAssignmentCompatible( Object.class, Double.class ) );
1495        assertFalse( isAssignmentCompatible( Object.class, Double.TYPE ) );
1496        assertFalse( isAssignmentCompatible( Object.class, double.class ) );
1497    }
1498
1499    @Test
1500    public void isAssignmentCompatibleObjectCharacter()
1501    {
1502        assertTrue( isAssignmentCompatible( Object.class, Character.class ) );
1503        assertFalse( isAssignmentCompatible( Object.class, Character.TYPE ) );
1504        assertFalse( isAssignmentCompatible( Object.class, char.class ) );
1505    }
1506
1507    @Test
1508    public void isAssignmentCompatibleObjectString()
1509    {
1510        assertTrue( isAssignmentCompatible( Object.class, String.class ) );
1511    }
1512
1513    @Test
1514    public void isAssignmentCompatibleObjectObject()
1515    {
1516        assertTrue( isAssignmentCompatible( Object.class, Object.class ) );
1517    }
1518
1519    @Test
1520    public void isAssignmentCompatibleObjectTestBean()
1521    {
1522        assertTrue( isAssignmentCompatible( Object.class, TestBean.class ) );
1523    }
1524
1525    @Test
1526    public void isAssignmentCompatibleTestBeanBoolean()
1527    {
1528
1529        assertFalse( isAssignmentCompatible( TestBean.class, Boolean.class ) );
1530        assertFalse( isAssignmentCompatible( TestBean.class, boolean.class ) );
1531        assertFalse( isAssignmentCompatible( TestBean.class, Boolean.TYPE ) );
1532    }
1533
1534    @Test
1535    public void isAssignmentCompatibleTestBeanByte()
1536    {
1537        assertFalse( isAssignmentCompatible( TestBean.class, Byte.class ) );
1538        assertFalse( isAssignmentCompatible( TestBean.class, Byte.TYPE ) );
1539        assertFalse( isAssignmentCompatible( TestBean.class, byte.class ) );
1540    }
1541
1542    @Test
1543    public void isAssignmentCompatibleTestBeanShort()
1544    {
1545        assertFalse( isAssignmentCompatible( TestBean.class, Short.class ) );
1546        assertFalse( isAssignmentCompatible( TestBean.class, Short.TYPE ) );
1547        assertFalse( isAssignmentCompatible( TestBean.class, short.class ) );
1548    }
1549
1550    @Test
1551    public void isAssignmentCompatibleTestBeanInteger()
1552    {
1553        assertFalse( isAssignmentCompatible( TestBean.class, Integer.class ) );
1554        assertFalse( isAssignmentCompatible( TestBean.class, Integer.TYPE ) );
1555        assertFalse( isAssignmentCompatible( TestBean.class, int.class ) );
1556    }
1557
1558    @Test
1559    public void isAssignmentCompatibleTestBeanLong()
1560    {
1561        assertFalse( isAssignmentCompatible( TestBean.class, Long.class ) );
1562        assertFalse( isAssignmentCompatible( TestBean.class, Long.TYPE ) );
1563        assertFalse( isAssignmentCompatible( TestBean.class, long.class ) );
1564    }
1565
1566    @Test
1567    public void isAssignmentCompatibleTestBeanFloat()
1568    {
1569        assertFalse( isAssignmentCompatible( TestBean.class, Float.class ) );
1570        assertFalse( isAssignmentCompatible( TestBean.class, Float.TYPE ) );
1571        assertFalse( isAssignmentCompatible( TestBean.class, float.class ) );
1572    }
1573
1574    @Test
1575    public void isAssignmentCompatibleTestBeanDouble()
1576    {
1577        assertFalse( isAssignmentCompatible( TestBean.class, Double.class ) );
1578        assertFalse( isAssignmentCompatible( TestBean.class, Double.TYPE ) );
1579        assertFalse( isAssignmentCompatible( TestBean.class, double.class ) );
1580    }
1581
1582    @Test
1583    public void isAssignmentCompatibleTestBeanCharacter()
1584    {
1585        assertFalse( isAssignmentCompatible( TestBean.class, Character.class ) );
1586        assertFalse( isAssignmentCompatible( TestBean.class, Character.TYPE ) );
1587        assertFalse( isAssignmentCompatible( TestBean.class, char.class ) );
1588    }
1589
1590    @Test
1591    public void isAssignmentCompatibleTestBeanString()
1592    {
1593        assertFalse( isAssignmentCompatible( TestBean.class, String.class ) );
1594    }
1595
1596    @Test
1597    public void isAssignmentCompatibleTestBeanObject()
1598    {
1599        assertFalse( isAssignmentCompatible( TestBean.class, Object.class ) );
1600    }
1601
1602    @Test
1603    public void isAssignmentCompatibleTestBeanTestBean()
1604    {
1605        assertTrue( isAssignmentCompatible( TestBean.class, TestBean.class ) );
1606    }
1607
1608    @Test( expected = NullPointerException.class )
1609    public void isAssignmentCompatibleNullClass()
1610    {
1611        isAssignmentCompatible( null, getClass() );
1612    }
1613
1614    @Test( expected = NullPointerException.class )
1615    public void isAssignmentCompatibleClassNull()
1616    {
1617        isAssignmentCompatible( getClass(), null );
1618    }
1619
1620    @Test( expected = NullPointerException.class )
1621    public void isAssignmentCompatibleNullNull()
1622    {
1623        TypeUtils.isAssignmentCompatible( getClass(), null );
1624    }
1625
1626    @Test
1627    public void getPrimitiveWrapperPrimitives()
1628    {
1629        assertEquals( Boolean.class, getPrimitiveWrapper( boolean.class ) );
1630        assertEquals( Byte.class, getPrimitiveWrapper( byte.class ) );
1631        assertEquals( Short.class, getPrimitiveWrapper( short.class ) );
1632        assertEquals( Integer.class, getPrimitiveWrapper( int.class ) );
1633        assertEquals( Long.class, getPrimitiveWrapper( long.class ) );
1634        assertEquals( Float.class, getPrimitiveWrapper( float.class ) );
1635        assertEquals( Double.class, getPrimitiveWrapper( double.class ) );
1636        assertEquals( Character.class, getPrimitiveWrapper( char.class ) );
1637    }
1638
1639    @Test
1640    public void getPrimitiveWrapperWrappers()
1641    {
1642        assertNull( getPrimitiveWrapper( Boolean.class ) );
1643        assertNull( getPrimitiveWrapper( Byte.class ) );
1644        assertNull( getPrimitiveWrapper( Short.class ) );
1645        assertNull( getPrimitiveWrapper( Integer.class ) );
1646        assertNull( getPrimitiveWrapper( Long.class ) );
1647        assertNull( getPrimitiveWrapper( Float.class ) );
1648        assertNull( getPrimitiveWrapper( Double.class ) );
1649        assertNull( getPrimitiveWrapper( Character.class ) );
1650    }
1651
1652    @Test
1653    public void getPrimitiveWrapperString()
1654    {
1655        assertNull( getPrimitiveWrapper( String.class ) );
1656    }
1657
1658    @Test
1659    public void getPrimitiveWrapperObject()
1660    {
1661        assertNull( getPrimitiveWrapper( Object.class ) );
1662    }
1663
1664    @Test
1665    public void getPrimitiveWrapperTestBean()
1666    {
1667        assertNull( getPrimitiveWrapper( TestBean.class ) );
1668    }
1669
1670    @Test
1671    public void getPrimitiveWrapperNull()
1672    {
1673        assertNull( getPrimitiveWrapper( null ) );
1674    }
1675
1676    @Test
1677    public void getPrimitiveTypePrimitives()
1678    {
1679        assertEquals( boolean.class, getPrimitiveType( Boolean.class ) );
1680        assertEquals( byte.class, getPrimitiveType( Byte.class ) );
1681        assertEquals( short.class, getPrimitiveType( Short.class ) );
1682        assertEquals( int.class, getPrimitiveType( Integer.class ) );
1683        assertEquals( long.class, getPrimitiveType( Long.class ) );
1684        assertEquals( float.class, getPrimitiveType( Float.class ) );
1685        assertEquals( double.class, getPrimitiveType( Double.class ) );
1686        assertEquals( char.class, getPrimitiveType( Character.class ) );
1687    }
1688
1689    @Test
1690    public void getPrimitiveTypeWrappers()
1691    {
1692        assertNull( getPrimitiveType( boolean.class ) );
1693        assertNull( getPrimitiveType( byte.class ) );
1694        assertNull( getPrimitiveType( short.class ) );
1695        assertNull( getPrimitiveType( int.class ) );
1696        assertNull( getPrimitiveType( long.class ) );
1697        assertNull( getPrimitiveType( float.class ) );
1698        assertNull( getPrimitiveType( double.class ) );
1699        assertNull( getPrimitiveType( char.class ) );
1700    }
1701
1702    @Test
1703    public void getPrimitiveTypeString()
1704    {
1705        assertNull( getPrimitiveType( String.class ) );
1706    }
1707
1708    @Test
1709    public void getPrimitiveTypeObject()
1710    {
1711        assertNull( getPrimitiveType( Object.class ) );
1712    }
1713
1714    @Test
1715    public void getPrimitiveTypeTestBean()
1716    {
1717        assertNull( getPrimitiveType( TestBean.class ) );
1718    }
1719
1720    @Test
1721    public void getPrimitiveTypeNull()
1722    {
1723        assertNull( getPrimitiveType( null ) );
1724    }
1725
1726    @Test
1727    public void toNonPrimitiveClassBooleanPrimitive()
1728    {
1729        assertEquals( Boolean.class, toNonPrimitiveClass( boolean.class ) );
1730    }
1731
1732    @Test
1733    public void toNonPrimitiveClassBooleanWrapper()
1734    {
1735        Class<Boolean> booleanClass = Boolean.class;
1736        assertSame( booleanClass, toNonPrimitiveClass( booleanClass ) );
1737        assertEquals( booleanClass, toNonPrimitiveClass( boolean.class ) );
1738
1739    }
1740
1741    @Test
1742    public void toNonPrimitiveClassBytePrimitive()
1743    {
1744        assertEquals( Byte.class, toNonPrimitiveClass( byte.class ) );
1745    }
1746
1747    @Test
1748    public void toNonPrimitiveClassByteWrapper()
1749    {
1750        Class<Byte> byteClass = Byte.class;
1751        assertSame( byteClass, toNonPrimitiveClass( byteClass ) );
1752        assertEquals( byteClass, toNonPrimitiveClass( byte.class ) );
1753    }
1754
1755    @Test
1756    public void toNonPrimitiveClassShortPrimitive()
1757    {
1758        assertEquals( Short.class, toNonPrimitiveClass( short.class ) );
1759    }
1760
1761    @Test
1762    public void toNonPrimitiveClassShortWrapper()
1763    {
1764        Class<Short> shortClass = Short.class;
1765        assertSame( shortClass, toNonPrimitiveClass( shortClass ) );
1766        assertEquals( shortClass, toNonPrimitiveClass( short.class ) );
1767    }
1768
1769    @Test
1770    public void toNonPrimitiveClassIntegerPrimitive()
1771    {
1772        assertEquals( Integer.class, toNonPrimitiveClass( int.class ) );
1773    }
1774
1775    @Test
1776    public void toNonPrimitiveClassIntegerWrapper()
1777    {
1778        Class<Integer> integerClass = Integer.class;
1779        assertSame( integerClass, toNonPrimitiveClass( integerClass ) );
1780        assertEquals( integerClass, toNonPrimitiveClass( int.class ) );
1781    }
1782
1783    @Test
1784    public void toNonPrimitiveClassLongPrimitive()
1785    {
1786        assertEquals( Long.class, toNonPrimitiveClass( long.class ) );
1787    }
1788
1789    @Test
1790    public void toNonPrimitiveClassLongWrapper()
1791    {
1792        Class<Long> longClass = Long.class;
1793        assertSame( longClass, toNonPrimitiveClass( longClass ) );
1794        assertEquals( longClass, toNonPrimitiveClass( long.class ) );
1795    }
1796
1797    @Test
1798    public void toNonPrimitiveClassFloatPrimitive()
1799    {
1800        assertEquals( Float.class, toNonPrimitiveClass( float.class ) );
1801    }
1802
1803    @Test
1804    public void toNonPrimitiveClassFloatWrapper()
1805    {
1806        Class<Float> floatClass = Float.class;
1807        assertSame( floatClass, toNonPrimitiveClass( floatClass ) );
1808        assertEquals( floatClass, toNonPrimitiveClass( float.class ) );
1809    }
1810
1811    @Test
1812    public void toNonPrimitiveClassDoublePrimitive()
1813    {
1814        assertEquals( Double.class, toNonPrimitiveClass( double.class ) );
1815    }
1816
1817    @Test
1818    public void toNonPrimitiveClassDoubleWrapper()
1819    {
1820        Class<Double> doubleClass = Double.class;
1821        assertSame( doubleClass, toNonPrimitiveClass( doubleClass ) );
1822        assertEquals( doubleClass, toNonPrimitiveClass( double.class ) );
1823    }
1824
1825    @Test
1826    public void toNonPrimitiveClassCharacterPrimitive()
1827    {
1828        assertEquals( Character.class, toNonPrimitiveClass( char.class ) );
1829    }
1830
1831    @Test
1832    public void toNonPrimitiveClassCharacterWrapper()
1833    {
1834        Class<Character> characterClass = Character.class;
1835        assertSame( characterClass, toNonPrimitiveClass( characterClass ) );
1836        assertEquals( characterClass, toNonPrimitiveClass( char.class ) );
1837    }
1838
1839    @Test
1840    public void toNonPrimitiveClassString()
1841    {
1842        Class<String> stringClass = String.class;
1843        assertSame( stringClass, toNonPrimitiveClass( stringClass ) );
1844    }
1845
1846    @Test
1847    public void toNonPrimitiveClassObject()
1848    {
1849        Class<Object> objectClass = Object.class;
1850        assertSame( objectClass, toNonPrimitiveClass( objectClass ) );
1851    }
1852
1853    @Test
1854    public void toNonPrimitiveClassTestBean()
1855    {
1856        Class<TestBean> testBeanClass = TestBean.class;
1857        assertSame( testBeanClass, toNonPrimitiveClass( testBeanClass ) );
1858    }
1859
1860    @Test( expected = NullPointerException.class )
1861    public void toNonPrimitiveNull()
1862    {
1863        toNonPrimitiveClass( null );
1864    }
1865
1866    @Test
1867    public void checkTypesCompatibleWithCompatibleTypes()
1868    {
1869        Class<?>[] primitives = new Class<?>[] { boolean.class, byte.class, short.class,
1870                int.class, long.class, float.class, double.class, char.class };
1871
1872        Class<?>[] wrappers = new Class<?>[] { Boolean.class, Byte.class, Short.class,
1873            Integer.class, Long.class, Float.class, Double.class, Character.class };
1874
1875        assertTrue(checkTypesCompatible(primitives, wrappers));
1876    }
1877
1878    @Test
1879    public void checkTypesCompatibleWithIncompatibleTypes()
1880    {
1881        Class<?>[] primitives = new Class<?>[] { boolean.class, byte.class, short.class,
1882            int.class, long.class, float.class, double.class, char.class };
1883
1884        Class<?>[] objects = new Class<?>[] { String.class, Object.class, TestBean.class };
1885
1886        assertFalse(checkTypesCompatible(primitives, objects));
1887    }
1888
1889    @Test( expected = NullPointerException.class )
1890    public void checkTypesCompatibleArrayNull()
1891    {
1892        Class<?>[] types = new Class<?>[0];
1893        Class<?>[] otherTypes = null;
1894        checkTypesCompatible( types, otherTypes );
1895    }
1896
1897    @Test( expected = NullPointerException.class )
1898    public void checkTypesCompatibleNullArray()
1899    {
1900        Class<?>[] types = null;
1901        Class<?>[] otherTypes = new Class<?>[0];
1902        checkTypesCompatible( types, otherTypes );
1903    }
1904
1905    @Test( expected = NullPointerException.class )
1906    public void checkTypesCompatibleNullNull()
1907    {
1908        Class<?>[] types = null;
1909        Class<?>[] otherTypes = null;
1910        checkTypesCompatible( types, otherTypes );
1911    }
1912
1913    @Test( expected = NullPointerException.class )
1914    public void checkTypesCompatibleArrayWithNullReference()
1915    {
1916        Class<?>[] primitives = new Class<?>[] { boolean.class, null, short.class };
1917        Class<?>[] objects = new Class<?>[] { String.class, Object.class, TestBean.class };
1918
1919        checkTypesCompatible(primitives, objects);
1920    }
1921
1922}