1 package org.apache.commons.beanutils2;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import static org.apache.commons.beanutils2.TypeUtils.checkTypesCompatible;
23 import static org.apache.commons.beanutils2.TypeUtils.getPrimitiveType;
24 import static org.apache.commons.beanutils2.TypeUtils.getPrimitiveWrapper;
25 import static org.apache.commons.beanutils2.TypeUtils.isAssignmentCompatible;
26 import static org.apache.commons.beanutils2.TypeUtils.toNonPrimitiveClass;
27 import static org.junit.Assert.assertEquals;
28 import static org.junit.Assert.assertFalse;
29 import static org.junit.Assert.assertNull;
30 import static org.junit.Assert.assertSame;
31 import static org.junit.Assert.assertTrue;
32
33 import org.apache.commons.beanutils2.testbeans.TestBean;
34 import org.junit.Test;
35
36 public class TypeUtilsTest
37 {
38
39 @Test
40 public void isAssignmentCompatibleBooleanPrimitiveBoolean()
41 {
42 assertTrue( isAssignmentCompatible( boolean.class, Boolean.class ) );
43 assertTrue( isAssignmentCompatible( boolean.class, Boolean.TYPE ) );
44 assertTrue( isAssignmentCompatible( boolean.class, boolean.class ) );
45 }
46
47 @Test
48 public void isAssignmentCompatibleBooleanPrimitiveByte()
49 {
50 assertFalse( isAssignmentCompatible( boolean.class, Byte.class ) );
51 assertFalse( isAssignmentCompatible( boolean.class, Byte.TYPE ) );
52 assertFalse( isAssignmentCompatible( boolean.class, byte.class ) );
53 }
54
55 @Test
56 public void isAssignmentCompatibleBooleanPrimitiveShort()
57 {
58 assertFalse( isAssignmentCompatible( boolean.class, Short.class ) );
59 assertFalse( isAssignmentCompatible( boolean.class, Short.TYPE ) );
60 assertFalse( isAssignmentCompatible( boolean.class, short.class ) );
61 }
62
63 @Test
64 public void isAssignmentCompatibleBooleanPrimitiveInteger()
65 {
66 assertFalse( isAssignmentCompatible( boolean.class, Integer.class ) );
67 assertFalse( isAssignmentCompatible( boolean.class, Integer.TYPE ) );
68 assertFalse( isAssignmentCompatible( boolean.class, int.class ) );
69 }
70
71 @Test
72 public void isAssignmentCompatibleBooleanPrimitiveLong()
73 {
74 assertFalse( isAssignmentCompatible( boolean.class, Long.class ) );
75 assertFalse( isAssignmentCompatible( boolean.class, Long.TYPE ) );
76 assertFalse( isAssignmentCompatible( boolean.class, long.class ) );
77 }
78
79 @Test
80 public void isAssignmentCompatibleBooleanPrimitveFloat()
81 {
82 assertFalse( isAssignmentCompatible( boolean.class, Float.class ) );
83 assertFalse( isAssignmentCompatible( boolean.class, Float.TYPE ) );
84 assertFalse( isAssignmentCompatible( boolean.class, float.class ) );
85 }
86
87 @Test
88 public void isAssignmentCompatibleBooleanPrimitveDouble()
89 {
90 assertFalse( isAssignmentCompatible( boolean.class, Double.class ) );
91 assertFalse( isAssignmentCompatible( boolean.class, Double.TYPE ) );
92 assertFalse( isAssignmentCompatible( boolean.class, double.class ) );
93 }
94
95 @Test
96 public void isAssignmentCompatibleBooleanPrimitveCharacter()
97 {
98 assertFalse( isAssignmentCompatible( boolean.class, Character.class ) );
99 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 }