1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 package org.apache.commons.lang3; 18 19 import static org.junit.jupiter.api.Assertions.assertArrayEquals; 20 import static org.junit.jupiter.api.Assertions.assertEquals; 21 import static org.junit.jupiter.api.Assertions.assertFalse; 22 import static org.junit.jupiter.api.Assertions.assertNotNull; 23 import static org.junit.jupiter.api.Assertions.assertNotSame; 24 import static org.junit.jupiter.api.Assertions.assertNull; 25 import static org.junit.jupiter.api.Assertions.assertSame; 26 import static org.junit.jupiter.api.Assertions.assertThrows; 27 import static org.junit.jupiter.api.Assertions.assertTrue; 28 29 import java.lang.reflect.Constructor; 30 import java.lang.reflect.Method; 31 import java.lang.reflect.Modifier; 32 import java.util.ArrayList; 33 import java.util.Collections; 34 import java.util.HashSet; 35 import java.util.Iterator; 36 import java.util.List; 37 import java.util.Map; 38 import java.util.Set; 39 import java.util.TreeMap; 40 41 import org.apache.commons.lang3.ClassUtils.Interfaces; 42 import org.apache.commons.lang3.reflect.testbed.GenericConsumer; 43 import org.apache.commons.lang3.reflect.testbed.GenericParent; 44 import org.apache.commons.lang3.reflect.testbed.StringParameterizedChild; 45 import org.junit.jupiter.api.Assertions; 46 import org.junit.jupiter.api.DisplayName; 47 import org.junit.jupiter.api.Test; 48 49 /** 50 * Unit tests {@link org.apache.commons.lang3.ClassUtils}. 51 */ 52 @SuppressWarnings("boxing") // JUnit4 does not support primitive equality testing apart from long 53 public class ClassUtilsTest extends AbstractLangTest { 54 55 private static final String OBJECT_CANONICAL_NAME = "java.lang.Object"; 56 57 private static class CX implements IB, IA, IE { 58 // empty 59 } 60 61 @SuppressWarnings("unused") // IB is redundant but what a test checks 62 private static class CY extends CX implements IB, IC { 63 // empty 64 } 65 66 private interface IA { 67 // empty 68 } 69 70 private interface IB { 71 // empty 72 } 73 74 private interface IC extends ID, IE { 75 // empty 76 } 77 78 private interface ID { 79 // empty 80 } 81 82 private interface IE extends IF { 83 // empty 84 } 85 86 private interface IF { 87 // empty 88 } 89 90 private static class Inner { 91 private class DeeplyNested { 92 // empty 93 } 94 } 95 assertGetClassReturnsClass(final Class<?> c)96 private void assertGetClassReturnsClass(final Class<?> c) throws Exception { 97 assertEquals(c, ClassUtils.getClass(c.getName())); 98 } 99 assertGetClassThrowsClassNotFound(final String className)100 private void assertGetClassThrowsClassNotFound(final String className) { 101 assertGetClassThrowsException(className, ClassNotFoundException.class); 102 } 103 assertGetClassThrowsException(final String className, final Class<? extends Exception> exceptionType)104 private void assertGetClassThrowsException(final String className, final Class<? extends Exception> exceptionType) { 105 assertThrows(exceptionType, () -> ClassUtils.getClass(className), 106 "ClassUtils.getClass() should fail with an exception of type " + exceptionType.getName() + " when given class name \"" + className + "\"."); 107 } 108 assertGetClassThrowsNullPointerException(final String className)109 private void assertGetClassThrowsNullPointerException(final String className) { 110 assertGetClassThrowsException(className, NullPointerException.class); 111 } 112 113 @Test test_convertClassesToClassNames_List()114 public void test_convertClassesToClassNames_List() { 115 final List<Class<?>> list = new ArrayList<>(); 116 List<String> result = ClassUtils.convertClassesToClassNames(list); 117 assertEquals(0, result.size()); 118 119 list.add(String.class); 120 list.add(null); 121 list.add(Object.class); 122 result = ClassUtils.convertClassesToClassNames(list); 123 assertEquals(3, result.size()); 124 assertEquals("java.lang.String", result.get(0)); 125 assertNull(result.get(1)); 126 assertEquals(OBJECT_CANONICAL_NAME, result.get(2)); 127 128 @SuppressWarnings("unchecked") // test what happens when non-generic code adds wrong type of element 129 final List<Object> olist = (List<Object>) (List<?>) list; 130 olist.add(new Object()); 131 assertThrows(ClassCastException.class, () -> ClassUtils.convertClassesToClassNames(list), "Should not have been able to convert list"); 132 assertNull(ClassUtils.convertClassesToClassNames(null)); 133 } 134 135 @Test test_convertClassNamesToClasses_List()136 public void test_convertClassNamesToClasses_List() { 137 final List<String> list = new ArrayList<>(); 138 List<Class<?>> result = ClassUtils.convertClassNamesToClasses(list); 139 assertEquals(0, result.size()); 140 141 list.add("java.lang.String"); 142 list.add("java.lang.xxx"); 143 list.add(OBJECT_CANONICAL_NAME); 144 result = ClassUtils.convertClassNamesToClasses(list); 145 assertEquals(3, result.size()); 146 assertEquals(String.class, result.get(0)); 147 assertNull(result.get(1)); 148 assertEquals(Object.class, result.get(2)); 149 150 @SuppressWarnings("unchecked") // test what happens when non-generic code adds wrong type of element 151 final List<Object> olist = (List<Object>) (List<?>) list; 152 olist.add(new Object()); 153 assertThrows(ClassCastException.class, () -> ClassUtils.convertClassNamesToClasses(list), "Should not have been able to convert list"); 154 assertNull(ClassUtils.convertClassNamesToClasses(null)); 155 } 156 157 @Test test_getAbbreviatedName_Class()158 public void test_getAbbreviatedName_Class() { 159 assertEquals("", ClassUtils.getAbbreviatedName((Class<?>) null, 1)); 160 assertEquals("j.l.String", ClassUtils.getAbbreviatedName(String.class, 1)); 161 assertEquals("j.l.String", ClassUtils.getAbbreviatedName(String.class, 5)); 162 assertEquals("o.a.c.l.ClassUtils", ClassUtils.getAbbreviatedName(ClassUtils.class, 18)); 163 assertEquals("j.lang.String", ClassUtils.getAbbreviatedName(String.class, 13)); 164 assertEquals("j.lang.String", ClassUtils.getAbbreviatedName(String.class, 15)); 165 assertEquals("java.lang.String", ClassUtils.getAbbreviatedName(String.class, 20)); 166 } 167 168 @Test 169 @DisplayName("When the desired length is negative then exception is thrown") test_getAbbreviatedName_Class_NegativeLen()170 public void test_getAbbreviatedName_Class_NegativeLen() { 171 assertThrows(IllegalArgumentException.class, () -> ClassUtils.getAbbreviatedName(String.class, -10)); 172 } 173 174 @Test 175 @DisplayName("When the desired length is zero then exception is thrown") test_getAbbreviatedName_Class_ZeroLen()176 public void test_getAbbreviatedName_Class_ZeroLen() { 177 assertThrows(IllegalArgumentException.class, () -> ClassUtils.getAbbreviatedName(String.class, 0)); 178 } 179 180 @Test test_getAbbreviatedName_String()181 public void test_getAbbreviatedName_String() { 182 assertEquals("", ClassUtils.getAbbreviatedName((String) null, 1)); 183 assertEquals("", ClassUtils.getAbbreviatedName("", 1)); 184 assertEquals("WithoutPackage", ClassUtils.getAbbreviatedName("WithoutPackage", 1)); 185 assertEquals("j.l.String", ClassUtils.getAbbreviatedName("java.lang.String", 1)); 186 assertEquals("o.a.c.l.ClassUtils", ClassUtils.getAbbreviatedName("org.apache.commons.lang3.ClassUtils", 18)); 187 assertEquals("org.apache.commons.lang3.ClassUtils", 188 ClassUtils.getAbbreviatedName("org.apache.commons.lang3.ClassUtils", "org.apache.commons.lang3.ClassUtils".length())); 189 assertEquals("o.a.c.l.ClassUtils", ClassUtils.getAbbreviatedName("o.a.c.l.ClassUtils", 18)); 190 assertEquals("o..c.l.ClassUtils", ClassUtils.getAbbreviatedName("o..c.l.ClassUtils", 18)); 191 assertEquals(".", ClassUtils.getAbbreviatedName(".", 18)); 192 assertEquals(".", ClassUtils.getAbbreviatedName(".", 1)); 193 assertEquals("..", ClassUtils.getAbbreviatedName("..", 1)); 194 assertEquals("...", ClassUtils.getAbbreviatedName("...", 2)); 195 assertEquals("...", ClassUtils.getAbbreviatedName("...", 3)); 196 assertEquals("java.lang.String", ClassUtils.getAbbreviatedName("java.lang.String", Integer.MAX_VALUE)); 197 assertEquals("j.lang.String", ClassUtils.getAbbreviatedName("java.lang.String", "j.lang.String".length())); 198 assertEquals("j.l.String", ClassUtils.getAbbreviatedName("java.lang.String", "j.lang.String".length() - 1)); 199 assertEquals("j.l.String", ClassUtils.getAbbreviatedName("java.lang.String", "j.l.String".length())); 200 assertEquals("j.l.String", ClassUtils.getAbbreviatedName("java.lang.String", "j.l.String".length() - 1)); 201 } 202 203 /** 204 * Test that in case the required length is larger than the name and thus there is no need for any shortening then the 205 * returned string object is the same as the one passed as argument. Note, however, that this is tested as an internal 206 * implementation detail, but it is not a guaranteed feature of the implementation. 207 */ 208 @Test 209 @DisplayName("When the length hint is longer than the actual length then the same String object is returned") test_getAbbreviatedName_TooLongHint()210 public void test_getAbbreviatedName_TooLongHint() { 211 final String className = "java.lang.String"; 212 Assertions.assertSame(className, ClassUtils.getAbbreviatedName(className, className.length() + 1)); 213 Assertions.assertSame(className, ClassUtils.getAbbreviatedName(className, className.length())); 214 } 215 216 @Test test_getAllInterfaces_Class()217 public void test_getAllInterfaces_Class() { 218 final List<?> list = ClassUtils.getAllInterfaces(CY.class); 219 assertEquals(6, list.size()); 220 assertEquals(IB.class, list.get(0)); 221 assertEquals(IC.class, list.get(1)); 222 assertEquals(ID.class, list.get(2)); 223 assertEquals(IE.class, list.get(3)); 224 assertEquals(IF.class, list.get(4)); 225 assertEquals(IA.class, list.get(5)); 226 227 assertNull(ClassUtils.getAllInterfaces(null)); 228 } 229 230 @Test test_getAllSuperclasses_Class()231 public void test_getAllSuperclasses_Class() { 232 final List<?> list = ClassUtils.getAllSuperclasses(CY.class); 233 assertEquals(2, list.size()); 234 assertEquals(CX.class, list.get(0)); 235 assertEquals(Object.class, list.get(1)); 236 237 assertNull(ClassUtils.getAllSuperclasses(null)); 238 } 239 240 @Test test_getCanonicalName_Class()241 public void test_getCanonicalName_Class() { 242 assertEquals("org.apache.commons.lang3.ClassUtils", ClassUtils.getCanonicalName(ClassUtils.class)); 243 assertEquals("java.util.Map.Entry", ClassUtils.getCanonicalName(Map.Entry.class)); 244 assertEquals("", ClassUtils.getCanonicalName((Class<?>) null)); 245 246 assertEquals("java.lang.String[]", ClassUtils.getCanonicalName(String[].class)); 247 assertEquals("java.util.Map.Entry[]", ClassUtils.getCanonicalName(Map.Entry[].class)); 248 249 // Primitives 250 assertEquals("boolean", ClassUtils.getCanonicalName(boolean.class)); 251 assertEquals("byte", ClassUtils.getCanonicalName(byte.class)); 252 assertEquals("char", ClassUtils.getCanonicalName(char.class)); 253 assertEquals("short", ClassUtils.getCanonicalName(short.class)); 254 assertEquals("int", ClassUtils.getCanonicalName(int.class)); 255 assertEquals("long", ClassUtils.getCanonicalName(long.class)); 256 assertEquals("float", ClassUtils.getCanonicalName(float.class)); 257 assertEquals("double", ClassUtils.getCanonicalName(double.class)); 258 259 // Primitive Arrays 260 assertEquals("boolean[]", ClassUtils.getCanonicalName(boolean[].class)); 261 assertEquals("byte[]", ClassUtils.getCanonicalName(byte[].class)); 262 assertEquals("char[]", ClassUtils.getCanonicalName(char[].class)); 263 assertEquals("short[]", ClassUtils.getCanonicalName(short[].class)); 264 assertEquals("int[]", ClassUtils.getCanonicalName(int[].class)); 265 assertEquals("long[]", ClassUtils.getCanonicalName(long[].class)); 266 assertEquals("float[]", ClassUtils.getCanonicalName(float[].class)); 267 assertEquals("double[]", ClassUtils.getCanonicalName(double[].class)); 268 269 // Arrays of arrays of ... 270 assertEquals("java.lang.String[][]", ClassUtils.getCanonicalName(String[][].class)); 271 assertEquals("java.lang.String[][][]", ClassUtils.getCanonicalName(String[][][].class)); 272 assertEquals("java.lang.String[][][][]", ClassUtils.getCanonicalName(String[][][][].class)); 273 274 // Inner types 275 class Named { 276 // empty 277 } 278 assertEquals(StringUtils.EMPTY, ClassUtils.getCanonicalName(new Object() { 279 // empty 280 }.getClass())); 281 assertEquals(StringUtils.EMPTY, ClassUtils.getCanonicalName(Named.class)); 282 assertEquals("org.apache.commons.lang3.ClassUtilsTest.Inner", ClassUtils.getCanonicalName(Inner.class)); 283 } 284 285 @Test test_getCanonicalName_Class_String()286 public void test_getCanonicalName_Class_String() { 287 assertEquals("org.apache.commons.lang3.ClassUtils", ClassUtils.getCanonicalName(ClassUtils.class, "X")); 288 assertEquals("java.util.Map.Entry", ClassUtils.getCanonicalName(Map.Entry.class, "X")); 289 assertEquals("X", ClassUtils.getCanonicalName((Class<?>) null, "X")); 290 291 assertEquals("java.lang.String[]", ClassUtils.getCanonicalName(String[].class, "X")); 292 assertEquals("java.util.Map.Entry[]", ClassUtils.getCanonicalName(Map.Entry[].class, "X")); 293 294 // Primitives 295 assertEquals("boolean", ClassUtils.getCanonicalName(boolean.class, "X")); 296 assertEquals("byte", ClassUtils.getCanonicalName(byte.class, "X")); 297 assertEquals("char", ClassUtils.getCanonicalName(char.class, "X")); 298 assertEquals("short", ClassUtils.getCanonicalName(short.class, "X")); 299 assertEquals("int", ClassUtils.getCanonicalName(int.class, "X")); 300 assertEquals("long", ClassUtils.getCanonicalName(long.class, "X")); 301 assertEquals("float", ClassUtils.getCanonicalName(float.class, "X")); 302 assertEquals("double", ClassUtils.getCanonicalName(double.class, "X")); 303 304 // Primitive Arrays 305 assertEquals("boolean[]", ClassUtils.getCanonicalName(boolean[].class, "X")); 306 assertEquals("byte[]", ClassUtils.getCanonicalName(byte[].class, "X")); 307 assertEquals("char[]", ClassUtils.getCanonicalName(char[].class, "X")); 308 assertEquals("short[]", ClassUtils.getCanonicalName(short[].class, "X")); 309 assertEquals("int[]", ClassUtils.getCanonicalName(int[].class, "X")); 310 assertEquals("long[]", ClassUtils.getCanonicalName(long[].class, "X")); 311 assertEquals("float[]", ClassUtils.getCanonicalName(float[].class, "X")); 312 assertEquals("double[]", ClassUtils.getCanonicalName(double[].class, "X")); 313 314 // Arrays of arrays of ... 315 assertEquals("java.lang.String[][]", ClassUtils.getCanonicalName(String[][].class, "X")); 316 assertEquals("java.lang.String[][][]", ClassUtils.getCanonicalName(String[][][].class, "X")); 317 assertEquals("java.lang.String[][][][]", ClassUtils.getCanonicalName(String[][][][].class, "X")); 318 319 // Inner types 320 class Named { 321 // empty 322 } 323 assertEquals("X", ClassUtils.getCanonicalName(new Object() { 324 // empty 325 }.getClass(), "X")); 326 assertEquals("X", ClassUtils.getCanonicalName(Named.class, "X")); 327 assertEquals("org.apache.commons.lang3.ClassUtilsTest.Inner", ClassUtils.getCanonicalName(Inner.class, "X")); 328 assertEquals("X", ClassUtils.getCanonicalName((Object) null, "X")); 329 assertEquals(OBJECT_CANONICAL_NAME, ClassUtils.getCanonicalName(new Object())); 330 } 331 332 @Test test_getClass()333 public void test_getClass() { 334 // assertEquals("org.apache.commons.lang3.ClassUtils", ClassUtils.getName(ClassLoader.class, "@")); 335 } 336 337 @Test test_getName_Class()338 public void test_getName_Class() { 339 assertEquals("org.apache.commons.lang3.ClassUtils", ClassUtils.getName(ClassUtils.class)); 340 assertEquals("java.util.Map$Entry", ClassUtils.getName(Map.Entry.class)); 341 assertEquals("", ClassUtils.getName((Class<?>) null)); 342 343 assertEquals("[Ljava.lang.String;", ClassUtils.getName(String[].class)); 344 assertEquals("[Ljava.util.Map$Entry;", ClassUtils.getName(Map.Entry[].class)); 345 346 // Primitives 347 assertEquals("boolean", ClassUtils.getName(boolean.class)); 348 assertEquals("byte", ClassUtils.getName(byte.class)); 349 assertEquals("char", ClassUtils.getName(char.class)); 350 assertEquals("short", ClassUtils.getName(short.class)); 351 assertEquals("int", ClassUtils.getName(int.class)); 352 assertEquals("long", ClassUtils.getName(long.class)); 353 assertEquals("float", ClassUtils.getName(float.class)); 354 assertEquals("double", ClassUtils.getName(double.class)); 355 356 // Primitive Arrays 357 assertEquals("[Z", ClassUtils.getName(boolean[].class)); 358 assertEquals("[B", ClassUtils.getName(byte[].class)); 359 assertEquals("[C", ClassUtils.getName(char[].class)); 360 assertEquals("[S", ClassUtils.getName(short[].class)); 361 assertEquals("[I", ClassUtils.getName(int[].class)); 362 assertEquals("[J", ClassUtils.getName(long[].class)); 363 assertEquals("[F", ClassUtils.getName(float[].class)); 364 assertEquals("[D", ClassUtils.getName(double[].class)); 365 366 // Arrays of arrays of ... 367 assertEquals("[[Ljava.lang.String;", ClassUtils.getName(String[][].class)); 368 assertEquals("[[[Ljava.lang.String;", ClassUtils.getName(String[][][].class)); 369 assertEquals("[[[[Ljava.lang.String;", ClassUtils.getName(String[][][][].class)); 370 371 // Inner types 372 class Named { 373 // empty 374 } 375 assertEquals("org.apache.commons.lang3.ClassUtilsTest$3", ClassUtils.getName(new Object() { 376 // empty 377 }.getClass())); 378 assertEquals("org.apache.commons.lang3.ClassUtilsTest$3Named", ClassUtils.getName(Named.class)); 379 assertEquals("org.apache.commons.lang3.ClassUtilsTest$Inner", ClassUtils.getName(Inner.class)); 380 assertEquals(OBJECT_CANONICAL_NAME, ClassUtils.getName(new Object())); 381 } 382 383 @Test test_getName_Object()384 public void test_getName_Object() { 385 assertEquals("org.apache.commons.lang3.ClassUtils", ClassUtils.getName(new ClassUtils(), "<null>")); 386 assertEquals("org.apache.commons.lang3.ClassUtilsTest$Inner", ClassUtils.getName(new Inner(), "<null>")); 387 assertEquals("java.lang.String", ClassUtils.getName("hello", "<null>")); 388 assertEquals("<null>", ClassUtils.getName(null, "<null>")); 389 390 // Inner types 391 class Named { 392 // empty 393 } 394 assertEquals("org.apache.commons.lang3.ClassUtilsTest$4", ClassUtils.getName(new Object() { 395 // empty 396 }, "<null>")); 397 assertEquals("org.apache.commons.lang3.ClassUtilsTest$4Named", ClassUtils.getName(new Named(), "<null>")); 398 assertEquals("org.apache.commons.lang3.ClassUtilsTest$Inner", ClassUtils.getName(new Inner(), "<null>")); 399 } 400 401 @Test test_getPackageCanonicalName_Class()402 public void test_getPackageCanonicalName_Class() { 403 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(ClassUtils.class)); 404 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(ClassUtils[].class)); 405 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(ClassUtils[][].class)); 406 assertEquals("", ClassUtils.getPackageCanonicalName(int[].class)); 407 assertEquals("", ClassUtils.getPackageCanonicalName(int[][].class)); 408 409 // Inner types 410 class Named { 411 // empty 412 } 413 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new Object() { 414 // empty 415 }.getClass())); 416 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(Named.class)); 417 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(Inner.class)); 418 assertEquals(StringUtils.EMPTY, ClassUtils.getPackageCanonicalName((Class<?>) null)); 419 } 420 421 @Test test_getPackageCanonicalName_Object()422 public void test_getPackageCanonicalName_Object() { 423 assertEquals("<null>", ClassUtils.getPackageCanonicalName(null, "<null>")); 424 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new ClassUtils(), "<null>")); 425 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new ClassUtils[0], "<null>")); 426 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new ClassUtils[0][0], "<null>")); 427 assertEquals("", ClassUtils.getPackageCanonicalName(new int[0], "<null>")); 428 assertEquals("", ClassUtils.getPackageCanonicalName(new int[0][0], "<null>")); 429 430 // Inner types 431 class Named { 432 // empty 433 } 434 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new Object() { 435 // empty 436 }, "<null>")); 437 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new Named(), "<null>")); 438 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new Inner(), "<null>")); 439 } 440 441 @Test test_getPackageCanonicalName_String()442 public void test_getPackageCanonicalName_String() { 443 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtils")); 444 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("[Lorg.apache.commons.lang3.ClassUtils;")); 445 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("[[Lorg.apache.commons.lang3.ClassUtils;")); 446 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtils[]")); 447 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtils[][]")); 448 assertEquals("", ClassUtils.getPackageCanonicalName("[I")); 449 assertEquals("", ClassUtils.getPackageCanonicalName("[[I")); 450 assertEquals("", ClassUtils.getPackageCanonicalName("int[]")); 451 assertEquals("", ClassUtils.getPackageCanonicalName("int[][]")); 452 453 // Inner types 454 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtilsTest$6")); 455 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtilsTest$5Named")); 456 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtilsTest$Inner")); 457 } 458 459 @Test test_getPackageName_Class()460 public void test_getPackageName_Class() { 461 assertEquals("java.lang", ClassUtils.getPackageName(String.class)); 462 assertEquals("java.util", ClassUtils.getPackageName(Map.Entry.class)); 463 assertEquals("", ClassUtils.getPackageName((Class<?>) null)); 464 465 // LANG-535 466 assertEquals("java.lang", ClassUtils.getPackageName(String[].class)); 467 468 // Primitive Arrays 469 assertEquals("", ClassUtils.getPackageName(boolean[].class)); 470 assertEquals("", ClassUtils.getPackageName(byte[].class)); 471 assertEquals("", ClassUtils.getPackageName(char[].class)); 472 assertEquals("", ClassUtils.getPackageName(short[].class)); 473 assertEquals("", ClassUtils.getPackageName(int[].class)); 474 assertEquals("", ClassUtils.getPackageName(long[].class)); 475 assertEquals("", ClassUtils.getPackageName(float[].class)); 476 assertEquals("", ClassUtils.getPackageName(double[].class)); 477 478 // Arrays of arrays of ... 479 assertEquals("java.lang", ClassUtils.getPackageName(String[][].class)); 480 assertEquals("java.lang", ClassUtils.getPackageName(String[][][].class)); 481 assertEquals("java.lang", ClassUtils.getPackageName(String[][][][].class)); 482 483 // On-the-fly types 484 class Named { 485 // empty 486 } 487 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(new Object() { 488 // empty 489 }.getClass())); 490 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(Named.class)); 491 } 492 493 @Test test_getPackageName_Object()494 public void test_getPackageName_Object() { 495 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(new ClassUtils(), "<null>")); 496 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(new Inner(), "<null>")); 497 assertEquals("<null>", ClassUtils.getPackageName(null, "<null>")); 498 } 499 500 @Test test_getPackageName_String()501 public void test_getPackageName_String() { 502 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(ClassUtils.class.getName())); 503 assertEquals("java.util", ClassUtils.getPackageName(Map.Entry.class.getName())); 504 assertEquals("", ClassUtils.getPackageName((String) null)); 505 assertEquals("", ClassUtils.getPackageName("")); 506 } 507 508 @Test test_getShortCanonicalName_Class()509 public void test_getShortCanonicalName_Class() { 510 assertEquals("ClassUtils", ClassUtils.getShortCanonicalName(ClassUtils.class)); 511 assertEquals("ClassUtils[]", ClassUtils.getShortCanonicalName(ClassUtils[].class)); 512 assertEquals("ClassUtils[][]", ClassUtils.getShortCanonicalName(ClassUtils[][].class)); 513 assertEquals("int[]", ClassUtils.getShortCanonicalName(int[].class)); 514 assertEquals("int[][]", ClassUtils.getShortCanonicalName(int[][].class)); 515 516 // Inner types 517 class Named { 518 // empty 519 } 520 assertEquals("", ClassUtils.getShortCanonicalName(new Object() { 521 // empty 522 }.getClass())); 523 // WARNING: this is fragile, implementation may change, naming is not guaranteed 524 assertEquals("", ClassUtils.getShortCanonicalName(Named.class)); 525 assertEquals("Inner", ClassUtils.getShortCanonicalName(Inner.class)); 526 assertEquals(StringUtils.EMPTY, ClassUtils.getShortCanonicalName((Class<?>) null)); 527 } 528 529 @Test test_getShortCanonicalName_Object()530 public void test_getShortCanonicalName_Object() { 531 assertEquals("<null>", ClassUtils.getShortCanonicalName(null, "<null>")); 532 assertEquals("ClassUtils", ClassUtils.getShortCanonicalName(new ClassUtils(), "<null>")); 533 assertEquals("ClassUtils[]", ClassUtils.getShortCanonicalName(new ClassUtils[0], "<null>")); 534 assertEquals("ClassUtils[][]", ClassUtils.getShortCanonicalName(new ClassUtils[0][0], "<null>")); 535 assertEquals("int[]", ClassUtils.getShortCanonicalName(new int[0], "<null>")); 536 assertEquals("int[][]", ClassUtils.getShortCanonicalName(new int[0][0], "<null>")); 537 538 // Inner types 539 class Named { 540 // empty 541 } 542 assertEquals("", ClassUtils.getShortCanonicalName(new Object() { 543 // empty 544 }, "<null>")); 545 assertEquals("", ClassUtils.getShortCanonicalName(new Named(), "<null>")); 546 assertEquals("Inner", ClassUtils.getShortCanonicalName(new Inner(), "<null>")); 547 } 548 549 @Test test_getShortCanonicalName_String()550 public void test_getShortCanonicalName_String() { 551 assertEquals("", ClassUtils.getShortCanonicalName((String) null)); 552 assertEquals("Map.Entry", ClassUtils.getShortCanonicalName(java.util.Map.Entry.class.getName())); 553 assertEquals("Entry", ClassUtils.getShortCanonicalName(java.util.Map.Entry.class.getCanonicalName())); 554 assertEquals("ClassUtils", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtils")); 555 assertEquals("ClassUtils[]", ClassUtils.getShortCanonicalName("[Lorg.apache.commons.lang3.ClassUtils;")); 556 assertEquals("ClassUtils[][]", ClassUtils.getShortCanonicalName("[[Lorg.apache.commons.lang3.ClassUtils;")); 557 assertEquals("ClassUtils[]", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtils[]")); 558 assertEquals("ClassUtils[][]", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtils[][]")); 559 assertEquals("int[]", ClassUtils.getShortCanonicalName("[I")); 560 assertEquals("int[]", ClassUtils.getShortCanonicalName(int[].class.getCanonicalName())); 561 assertEquals("int[]", ClassUtils.getShortCanonicalName(int[].class.getName())); 562 assertEquals("int[][]", ClassUtils.getShortCanonicalName("[[I")); 563 assertEquals("int[]", ClassUtils.getShortCanonicalName("int[]")); 564 assertEquals("int[][]", ClassUtils.getShortCanonicalName("int[][]")); 565 566 // this is to demonstrate that the documentation and the naming of the methods 567 // uses the class name and canonical name totally mixed up, which cannot be 568 // fixed without backward compatibility break 569 assertEquals("int[]", int[].class.getCanonicalName()); 570 assertEquals("[I", int[].class.getName()); 571 572 // Inner types... the problem is that these are not canonical names, classes with this name do not even have canonical 573 // name 574 // WARNING: this is fragile, implementation may change, naming is not guaranteed 575 assertEquals("ClassUtilsTest.6", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtilsTest$6")); 576 // WARNING: this is fragile, implementation may change, naming is not guaranteed 577 assertEquals("ClassUtilsTest.5Named", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtilsTest$5Named")); 578 assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtilsTest$Inner")); 579 // demonstrating what a canonical name is... it is a bigger issue to clean this up 580 assertEquals("org.apache.commons.lang3.ClassUtilsTest$10", new org.apache.commons.lang3.ClassUtilsTest() { 581 }.getClass().getName()); 582 assertNull(new org.apache.commons.lang3.ClassUtilsTest() { 583 }.getClass().getCanonicalName()); 584 } 585 586 @Test test_getShortClassName_Class()587 public void test_getShortClassName_Class() { 588 assertEquals("ClassUtils", ClassUtils.getShortClassName(ClassUtils.class)); 589 assertEquals("Map.Entry", ClassUtils.getShortClassName(Map.Entry.class)); 590 assertEquals("", ClassUtils.getShortClassName((Class<?>) null)); 591 592 // LANG-535 593 assertEquals("String[]", ClassUtils.getShortClassName(String[].class)); 594 assertEquals("Map.Entry[]", ClassUtils.getShortClassName(Map.Entry[].class)); 595 596 // Primitives 597 assertEquals("boolean", ClassUtils.getShortClassName(boolean.class)); 598 assertEquals("byte", ClassUtils.getShortClassName(byte.class)); 599 assertEquals("char", ClassUtils.getShortClassName(char.class)); 600 assertEquals("short", ClassUtils.getShortClassName(short.class)); 601 assertEquals("int", ClassUtils.getShortClassName(int.class)); 602 assertEquals("long", ClassUtils.getShortClassName(long.class)); 603 assertEquals("float", ClassUtils.getShortClassName(float.class)); 604 assertEquals("double", ClassUtils.getShortClassName(double.class)); 605 606 // Primitive Arrays 607 assertEquals("boolean[]", ClassUtils.getShortClassName(boolean[].class)); 608 assertEquals("byte[]", ClassUtils.getShortClassName(byte[].class)); 609 assertEquals("char[]", ClassUtils.getShortClassName(char[].class)); 610 assertEquals("short[]", ClassUtils.getShortClassName(short[].class)); 611 assertEquals("int[]", ClassUtils.getShortClassName(int[].class)); 612 assertEquals("long[]", ClassUtils.getShortClassName(long[].class)); 613 assertEquals("float[]", ClassUtils.getShortClassName(float[].class)); 614 assertEquals("double[]", ClassUtils.getShortClassName(double[].class)); 615 616 // Arrays of arrays of ... 617 assertEquals("String[][]", ClassUtils.getShortClassName(String[][].class)); 618 assertEquals("String[][][]", ClassUtils.getShortClassName(String[][][].class)); 619 assertEquals("String[][][][]", ClassUtils.getShortClassName(String[][][][].class)); 620 621 // Inner types 622 class Named { 623 // empty 624 } 625 // WARNING: this is fragile, implementation may change, naming is not guaranteed 626 assertEquals("ClassUtilsTest.12", ClassUtils.getShortClassName(new Object() { 627 // empty 628 }.getClass())); 629 // WARNING: this is fragile, implementation may change, naming is not guaranteed 630 assertEquals("ClassUtilsTest.10Named", ClassUtils.getShortClassName(Named.class)); 631 assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortClassName(Inner.class)); 632 } 633 634 @Test test_getShortClassName_Object()635 public void test_getShortClassName_Object() { 636 assertEquals("ClassUtils", ClassUtils.getShortClassName(new ClassUtils(), "<null>")); 637 assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortClassName(new Inner(), "<null>")); 638 assertEquals("String", ClassUtils.getShortClassName("hello", "<null>")); 639 assertEquals("<null>", ClassUtils.getShortClassName(null, "<null>")); 640 641 // Inner types 642 class Named { 643 // empty 644 } 645 // WARNING: this is fragile, implementation may change, naming is not guaranteed 646 assertEquals("ClassUtilsTest.13", ClassUtils.getShortClassName(new Object() { 647 // empty 648 }, "<null>")); 649 // WARNING: this is fragile, implementation may change, naming is not guaranteed 650 assertEquals("ClassUtilsTest.11Named", ClassUtils.getShortClassName(new Named(), "<null>")); 651 assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortClassName(new Inner(), "<null>")); 652 } 653 654 @Test test_getShortClassName_String()655 public void test_getShortClassName_String() { 656 assertEquals("ClassUtils", ClassUtils.getShortClassName(ClassUtils.class.getName())); 657 assertEquals("Map.Entry", ClassUtils.getShortClassName(Map.Entry.class.getName())); 658 assertEquals("", ClassUtils.getShortClassName((String) null)); 659 assertEquals("", ClassUtils.getShortClassName("")); 660 } 661 662 @Test test_getSimpleName_Class()663 public void test_getSimpleName_Class() { 664 assertEquals("ClassUtils", ClassUtils.getSimpleName(ClassUtils.class)); 665 assertEquals("Entry", ClassUtils.getSimpleName(Map.Entry.class)); 666 assertEquals("", ClassUtils.getSimpleName(null)); 667 668 // LANG-535 669 assertEquals("String[]", ClassUtils.getSimpleName(String[].class)); 670 assertEquals("Entry[]", ClassUtils.getSimpleName(Map.Entry[].class)); 671 672 // Primitives 673 assertEquals("boolean", ClassUtils.getSimpleName(boolean.class)); 674 assertEquals("byte", ClassUtils.getSimpleName(byte.class)); 675 assertEquals("char", ClassUtils.getSimpleName(char.class)); 676 assertEquals("short", ClassUtils.getSimpleName(short.class)); 677 assertEquals("int", ClassUtils.getSimpleName(int.class)); 678 assertEquals("long", ClassUtils.getSimpleName(long.class)); 679 assertEquals("float", ClassUtils.getSimpleName(float.class)); 680 assertEquals("double", ClassUtils.getSimpleName(double.class)); 681 682 // Primitive Arrays 683 assertEquals("boolean[]", ClassUtils.getSimpleName(boolean[].class)); 684 assertEquals("byte[]", ClassUtils.getSimpleName(byte[].class)); 685 assertEquals("char[]", ClassUtils.getSimpleName(char[].class)); 686 assertEquals("short[]", ClassUtils.getSimpleName(short[].class)); 687 assertEquals("int[]", ClassUtils.getSimpleName(int[].class)); 688 assertEquals("long[]", ClassUtils.getSimpleName(long[].class)); 689 assertEquals("float[]", ClassUtils.getSimpleName(float[].class)); 690 assertEquals("double[]", ClassUtils.getSimpleName(double[].class)); 691 692 // Arrays of arrays of ... 693 assertEquals("String[][]", ClassUtils.getSimpleName(String[][].class)); 694 assertEquals("String[][][]", ClassUtils.getSimpleName(String[][][].class)); 695 assertEquals("String[][][][]", ClassUtils.getSimpleName(String[][][][].class)); 696 697 // On-the-fly types 698 class Named { 699 // empty 700 } 701 assertEquals("", ClassUtils.getSimpleName(new Object() { 702 // empty 703 }.getClass())); 704 assertEquals("Named", ClassUtils.getSimpleName(Named.class)); 705 } 706 707 @Test test_getSimpleName_Object()708 public void test_getSimpleName_Object() { 709 assertEquals("ClassUtils", ClassUtils.getSimpleName(new ClassUtils())); 710 assertEquals("Inner", ClassUtils.getSimpleName(new Inner())); 711 assertEquals("String", ClassUtils.getSimpleName("hello")); 712 assertEquals(StringUtils.EMPTY, ClassUtils.getSimpleName(null)); 713 assertEquals(StringUtils.EMPTY, ClassUtils.getSimpleName(null)); 714 } 715 716 @Test test_getSimpleName_Object_String()717 public void test_getSimpleName_Object_String() { 718 assertEquals("ClassUtils", ClassUtils.getSimpleName(new ClassUtils(), "<null>")); 719 assertEquals("Inner", ClassUtils.getSimpleName(new Inner(), "<null>")); 720 assertEquals("String", ClassUtils.getSimpleName("hello", "<null>")); 721 assertEquals("<null>", ClassUtils.getSimpleName(null, "<null>")); 722 assertNull(ClassUtils.getSimpleName(null, null)); 723 } 724 725 @Test test_isAssignable()726 public void test_isAssignable() { 727 assertFalse(ClassUtils.isAssignable((Class<?>) null, null)); 728 assertFalse(ClassUtils.isAssignable(String.class, null)); 729 730 assertTrue(ClassUtils.isAssignable(null, Object.class)); 731 assertTrue(ClassUtils.isAssignable(null, Integer.class)); 732 assertFalse(ClassUtils.isAssignable(null, Integer.TYPE)); 733 assertTrue(ClassUtils.isAssignable(String.class, Object.class)); 734 assertTrue(ClassUtils.isAssignable(String.class, String.class)); 735 assertFalse(ClassUtils.isAssignable(Object.class, String.class)); 736 737 assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.class)); 738 assertTrue(ClassUtils.isAssignable(Integer.TYPE, Object.class)); 739 assertTrue(ClassUtils.isAssignable(Integer.class, Integer.TYPE)); 740 assertTrue(ClassUtils.isAssignable(Integer.class, Object.class)); 741 assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE)); 742 assertTrue(ClassUtils.isAssignable(Integer.class, Integer.class)); 743 assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.class)); 744 assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Object.class)); 745 assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.TYPE)); 746 assertTrue(ClassUtils.isAssignable(Boolean.class, Object.class)); 747 assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.TYPE)); 748 assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.class)); 749 } 750 751 @Test test_isAssignable_Autoboxing()752 public void test_isAssignable_Autoboxing() { 753 assertFalse(ClassUtils.isAssignable((Class<?>) null, null, true)); 754 assertFalse(ClassUtils.isAssignable(String.class, null, true)); 755 756 assertTrue(ClassUtils.isAssignable(null, Object.class, true)); 757 assertTrue(ClassUtils.isAssignable(null, Integer.class, true)); 758 assertFalse(ClassUtils.isAssignable(null, Integer.TYPE, true)); 759 assertTrue(ClassUtils.isAssignable(String.class, Object.class, true)); 760 assertTrue(ClassUtils.isAssignable(String.class, String.class, true)); 761 assertFalse(ClassUtils.isAssignable(Object.class, String.class, true)); 762 assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.class, true)); 763 assertTrue(ClassUtils.isAssignable(Integer.TYPE, Object.class, true)); 764 assertTrue(ClassUtils.isAssignable(Integer.class, Integer.TYPE, true)); 765 assertTrue(ClassUtils.isAssignable(Integer.class, Object.class, true)); 766 assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE, true)); 767 assertTrue(ClassUtils.isAssignable(Integer.class, Integer.class, true)); 768 assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.class, true)); 769 assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.TYPE, true)); 770 assertTrue(ClassUtils.isAssignable(Boolean.class, Object.class, true)); 771 assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.TYPE, true)); 772 assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.class, true)); 773 } 774 775 @Test test_isAssignable_ClassArray_ClassArray()776 public void test_isAssignable_ClassArray_ClassArray() { 777 final Class<?>[] array2 = new Class[] {Object.class, Object.class}; 778 final Class<?>[] array1 = new Class[] {Object.class}; 779 final Class<?>[] array1s = new Class[] {String.class}; 780 final Class<?>[] array0 = new Class[] {}; 781 final Class<?>[] arrayPrimitives = {Integer.TYPE, Boolean.TYPE}; 782 final Class<?>[] arrayWrappers = {Integer.class, Boolean.class}; 783 784 assertFalse(ClassUtils.isAssignable(array1, array2)); 785 assertFalse(ClassUtils.isAssignable(null, array2)); 786 assertTrue(ClassUtils.isAssignable(null, array0)); 787 assertTrue(ClassUtils.isAssignable(array0, array0)); 788 assertTrue(ClassUtils.isAssignable(array0, (Class<?>[]) null)); // explicit cast to avoid warning 789 assertTrue(ClassUtils.isAssignable(null, (Class<?>[]) null)); // explicit cast to avoid warning 790 791 assertFalse(ClassUtils.isAssignable(array1, array1s)); 792 assertTrue(ClassUtils.isAssignable(array1s, array1s)); 793 assertTrue(ClassUtils.isAssignable(array1s, array1)); 794 795 assertTrue(ClassUtils.isAssignable(arrayPrimitives, arrayWrappers)); 796 assertTrue(ClassUtils.isAssignable(arrayWrappers, arrayPrimitives)); 797 assertFalse(ClassUtils.isAssignable(arrayPrimitives, array1)); 798 assertFalse(ClassUtils.isAssignable(arrayWrappers, array1)); 799 assertTrue(ClassUtils.isAssignable(arrayPrimitives, array2)); 800 assertTrue(ClassUtils.isAssignable(arrayWrappers, array2)); 801 } 802 803 @Test test_isAssignable_ClassArray_ClassArray_Autoboxing()804 public void test_isAssignable_ClassArray_ClassArray_Autoboxing() { 805 final Class<?>[] array2 = new Class[] {Object.class, Object.class}; 806 final Class<?>[] array1 = new Class[] {Object.class}; 807 final Class<?>[] array1s = new Class[] {String.class}; 808 final Class<?>[] array0 = new Class[] {}; 809 final Class<?>[] arrayPrimitives = {Integer.TYPE, Boolean.TYPE}; 810 final Class<?>[] arrayWrappers = {Integer.class, Boolean.class}; 811 812 assertFalse(ClassUtils.isAssignable(array1, array2, true)); 813 assertFalse(ClassUtils.isAssignable(null, array2, true)); 814 assertTrue(ClassUtils.isAssignable(null, array0, true)); 815 assertTrue(ClassUtils.isAssignable(array0, array0, true)); 816 assertTrue(ClassUtils.isAssignable(array0, null, true)); 817 assertTrue(ClassUtils.isAssignable((Class[]) null, null, true)); 818 819 assertFalse(ClassUtils.isAssignable(array1, array1s, true)); 820 assertTrue(ClassUtils.isAssignable(array1s, array1s, true)); 821 assertTrue(ClassUtils.isAssignable(array1s, array1, true)); 822 823 assertTrue(ClassUtils.isAssignable(arrayPrimitives, arrayWrappers, true)); 824 assertTrue(ClassUtils.isAssignable(arrayWrappers, arrayPrimitives, true)); 825 assertFalse(ClassUtils.isAssignable(arrayPrimitives, array1, true)); 826 assertFalse(ClassUtils.isAssignable(arrayWrappers, array1, true)); 827 assertTrue(ClassUtils.isAssignable(arrayPrimitives, array2, true)); 828 assertTrue(ClassUtils.isAssignable(arrayWrappers, array2, true)); 829 } 830 831 @Test test_isAssignable_ClassArray_ClassArray_NoAutoboxing()832 public void test_isAssignable_ClassArray_ClassArray_NoAutoboxing() { 833 final Class<?>[] array2 = new Class[] {Object.class, Object.class}; 834 final Class<?>[] array1 = new Class[] {Object.class}; 835 final Class<?>[] array1s = new Class[] {String.class}; 836 final Class<?>[] array0 = new Class[] {}; 837 final Class<?>[] arrayPrimitives = {Integer.TYPE, Boolean.TYPE}; 838 final Class<?>[] arrayWrappers = {Integer.class, Boolean.class}; 839 840 assertFalse(ClassUtils.isAssignable(array1, array2, false)); 841 assertFalse(ClassUtils.isAssignable(null, array2, false)); 842 assertTrue(ClassUtils.isAssignable(null, array0, false)); 843 assertTrue(ClassUtils.isAssignable(array0, array0, false)); 844 assertTrue(ClassUtils.isAssignable(array0, null, false)); 845 assertTrue(ClassUtils.isAssignable((Class[]) null, null, false)); 846 847 assertFalse(ClassUtils.isAssignable(array1, array1s, false)); 848 assertTrue(ClassUtils.isAssignable(array1s, array1s, false)); 849 assertTrue(ClassUtils.isAssignable(array1s, array1, false)); 850 851 assertFalse(ClassUtils.isAssignable(arrayPrimitives, arrayWrappers, false)); 852 assertFalse(ClassUtils.isAssignable(arrayWrappers, arrayPrimitives, false)); 853 assertFalse(ClassUtils.isAssignable(arrayPrimitives, array1, false)); 854 assertFalse(ClassUtils.isAssignable(arrayWrappers, array1, false)); 855 assertTrue(ClassUtils.isAssignable(arrayWrappers, array2, false)); 856 assertFalse(ClassUtils.isAssignable(arrayPrimitives, array2, false)); 857 } 858 859 @Test test_isAssignable_DefaultUnboxing_Widening()860 public void test_isAssignable_DefaultUnboxing_Widening() { 861 // test byte conversions 862 assertFalse(ClassUtils.isAssignable(Byte.class, Character.TYPE), "byte -> char"); 863 assertTrue(ClassUtils.isAssignable(Byte.class, Byte.TYPE), "byte -> byte"); 864 assertTrue(ClassUtils.isAssignable(Byte.class, Short.TYPE), "byte -> short"); 865 assertTrue(ClassUtils.isAssignable(Byte.class, Integer.TYPE), "byte -> int"); 866 assertTrue(ClassUtils.isAssignable(Byte.class, Long.TYPE), "byte -> long"); 867 assertTrue(ClassUtils.isAssignable(Byte.class, Float.TYPE), "byte -> float"); 868 assertTrue(ClassUtils.isAssignable(Byte.class, Double.TYPE), "byte -> double"); 869 assertFalse(ClassUtils.isAssignable(Byte.class, Boolean.TYPE), "byte -> boolean"); 870 871 // test short conversions 872 assertFalse(ClassUtils.isAssignable(Short.class, Character.TYPE), "short -> char"); 873 assertFalse(ClassUtils.isAssignable(Short.class, Byte.TYPE), "short -> byte"); 874 assertTrue(ClassUtils.isAssignable(Short.class, Short.TYPE), "short -> short"); 875 assertTrue(ClassUtils.isAssignable(Short.class, Integer.TYPE), "short -> int"); 876 assertTrue(ClassUtils.isAssignable(Short.class, Long.TYPE), "short -> long"); 877 assertTrue(ClassUtils.isAssignable(Short.class, Float.TYPE), "short -> float"); 878 assertTrue(ClassUtils.isAssignable(Short.class, Double.TYPE), "short -> double"); 879 assertFalse(ClassUtils.isAssignable(Short.class, Boolean.TYPE), "short -> boolean"); 880 881 // test char conversions 882 assertTrue(ClassUtils.isAssignable(Character.class, Character.TYPE), "char -> char"); 883 assertFalse(ClassUtils.isAssignable(Character.class, Byte.TYPE), "char -> byte"); 884 assertFalse(ClassUtils.isAssignable(Character.class, Short.TYPE), "char -> short"); 885 assertTrue(ClassUtils.isAssignable(Character.class, Integer.TYPE), "char -> int"); 886 assertTrue(ClassUtils.isAssignable(Character.class, Long.TYPE), "char -> long"); 887 assertTrue(ClassUtils.isAssignable(Character.class, Float.TYPE), "char -> float"); 888 assertTrue(ClassUtils.isAssignable(Character.class, Double.TYPE), "char -> double"); 889 assertFalse(ClassUtils.isAssignable(Character.class, Boolean.TYPE), "char -> boolean"); 890 891 // test int conversions 892 assertFalse(ClassUtils.isAssignable(Integer.class, Character.TYPE), "int -> char"); 893 assertFalse(ClassUtils.isAssignable(Integer.class, Byte.TYPE), "int -> byte"); 894 assertFalse(ClassUtils.isAssignable(Integer.class, Short.TYPE), "int -> short"); 895 assertTrue(ClassUtils.isAssignable(Integer.class, Integer.TYPE), "int -> int"); 896 assertTrue(ClassUtils.isAssignable(Integer.class, Long.TYPE), "int -> long"); 897 assertTrue(ClassUtils.isAssignable(Integer.class, Float.TYPE), "int -> float"); 898 assertTrue(ClassUtils.isAssignable(Integer.class, Double.TYPE), "int -> double"); 899 assertFalse(ClassUtils.isAssignable(Integer.class, Boolean.TYPE), "int -> boolean"); 900 901 // test long conversions 902 assertFalse(ClassUtils.isAssignable(Long.class, Character.TYPE), "long -> char"); 903 assertFalse(ClassUtils.isAssignable(Long.class, Byte.TYPE), "long -> byte"); 904 assertFalse(ClassUtils.isAssignable(Long.class, Short.TYPE), "long -> short"); 905 assertFalse(ClassUtils.isAssignable(Long.class, Integer.TYPE), "long -> int"); 906 assertTrue(ClassUtils.isAssignable(Long.class, Long.TYPE), "long -> long"); 907 assertTrue(ClassUtils.isAssignable(Long.class, Float.TYPE), "long -> float"); 908 assertTrue(ClassUtils.isAssignable(Long.class, Double.TYPE), "long -> double"); 909 assertFalse(ClassUtils.isAssignable(Long.class, Boolean.TYPE), "long -> boolean"); 910 911 // test float conversions 912 assertFalse(ClassUtils.isAssignable(Float.class, Character.TYPE), "float -> char"); 913 assertFalse(ClassUtils.isAssignable(Float.class, Byte.TYPE), "float -> byte"); 914 assertFalse(ClassUtils.isAssignable(Float.class, Short.TYPE), "float -> short"); 915 assertFalse(ClassUtils.isAssignable(Float.class, Integer.TYPE), "float -> int"); 916 assertFalse(ClassUtils.isAssignable(Float.class, Long.TYPE), "float -> long"); 917 assertTrue(ClassUtils.isAssignable(Float.class, Float.TYPE), "float -> float"); 918 assertTrue(ClassUtils.isAssignable(Float.class, Double.TYPE), "float -> double"); 919 assertFalse(ClassUtils.isAssignable(Float.class, Boolean.TYPE), "float -> boolean"); 920 921 // test double conversions 922 assertFalse(ClassUtils.isAssignable(Double.class, Character.TYPE), "double -> char"); 923 assertFalse(ClassUtils.isAssignable(Double.class, Byte.TYPE), "double -> byte"); 924 assertFalse(ClassUtils.isAssignable(Double.class, Short.TYPE), "double -> short"); 925 assertFalse(ClassUtils.isAssignable(Double.class, Integer.TYPE), "double -> int"); 926 assertFalse(ClassUtils.isAssignable(Double.class, Long.TYPE), "double -> long"); 927 assertFalse(ClassUtils.isAssignable(Double.class, Float.TYPE), "double -> float"); 928 assertTrue(ClassUtils.isAssignable(Double.class, Double.TYPE), "double -> double"); 929 assertFalse(ClassUtils.isAssignable(Double.class, Boolean.TYPE), "double -> boolean"); 930 931 // test boolean conversions 932 assertFalse(ClassUtils.isAssignable(Boolean.class, Character.TYPE), "boolean -> char"); 933 assertFalse(ClassUtils.isAssignable(Boolean.class, Byte.TYPE), "boolean -> byte"); 934 assertFalse(ClassUtils.isAssignable(Boolean.class, Short.TYPE), "boolean -> short"); 935 assertFalse(ClassUtils.isAssignable(Boolean.class, Integer.TYPE), "boolean -> int"); 936 assertFalse(ClassUtils.isAssignable(Boolean.class, Long.TYPE), "boolean -> long"); 937 assertFalse(ClassUtils.isAssignable(Boolean.class, Float.TYPE), "boolean -> float"); 938 assertFalse(ClassUtils.isAssignable(Boolean.class, Double.TYPE), "boolean -> double"); 939 assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.TYPE), "boolean -> boolean"); 940 } 941 942 @Test test_isAssignable_NoAutoboxing()943 public void test_isAssignable_NoAutoboxing() { 944 assertFalse(ClassUtils.isAssignable((Class<?>) null, null, false)); 945 assertFalse(ClassUtils.isAssignable(String.class, null, false)); 946 947 assertTrue(ClassUtils.isAssignable(null, Object.class, false)); 948 assertTrue(ClassUtils.isAssignable(null, Integer.class, false)); 949 assertFalse(ClassUtils.isAssignable(null, Integer.TYPE, false)); 950 assertTrue(ClassUtils.isAssignable(String.class, Object.class, false)); 951 assertTrue(ClassUtils.isAssignable(String.class, String.class, false)); 952 assertFalse(ClassUtils.isAssignable(Object.class, String.class, false)); 953 assertFalse(ClassUtils.isAssignable(Integer.TYPE, Integer.class, false)); 954 assertFalse(ClassUtils.isAssignable(Integer.TYPE, Object.class, false)); 955 assertFalse(ClassUtils.isAssignable(Integer.class, Integer.TYPE, false)); 956 assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE, false)); 957 assertTrue(ClassUtils.isAssignable(Integer.class, Integer.class, false)); 958 assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Boolean.class, false)); 959 assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Object.class, false)); 960 assertFalse(ClassUtils.isAssignable(Boolean.class, Boolean.TYPE, false)); 961 assertTrue(ClassUtils.isAssignable(Boolean.class, Object.class, false)); 962 assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.TYPE, false)); 963 assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.class, false)); 964 } 965 966 @Test test_isAssignable_Unboxing_Widening()967 public void test_isAssignable_Unboxing_Widening() { 968 // test byte conversions 969 assertFalse(ClassUtils.isAssignable(Byte.class, Character.TYPE, true), "byte -> char"); 970 assertTrue(ClassUtils.isAssignable(Byte.class, Byte.TYPE, true), "byte -> byte"); 971 assertTrue(ClassUtils.isAssignable(Byte.class, Short.TYPE, true), "byte -> short"); 972 assertTrue(ClassUtils.isAssignable(Byte.class, Integer.TYPE, true), "byte -> int"); 973 assertTrue(ClassUtils.isAssignable(Byte.class, Long.TYPE, true), "byte -> long"); 974 assertTrue(ClassUtils.isAssignable(Byte.class, Float.TYPE, true), "byte -> float"); 975 assertTrue(ClassUtils.isAssignable(Byte.class, Double.TYPE, true), "byte -> double"); 976 assertFalse(ClassUtils.isAssignable(Byte.class, Boolean.TYPE, true), "byte -> boolean"); 977 978 // test short conversions 979 assertFalse(ClassUtils.isAssignable(Short.class, Character.TYPE, true), "short -> char"); 980 assertFalse(ClassUtils.isAssignable(Short.class, Byte.TYPE, true), "short -> byte"); 981 assertTrue(ClassUtils.isAssignable(Short.class, Short.TYPE, true), "short -> short"); 982 assertTrue(ClassUtils.isAssignable(Short.class, Integer.TYPE, true), "short -> int"); 983 assertTrue(ClassUtils.isAssignable(Short.class, Long.TYPE, true), "short -> long"); 984 assertTrue(ClassUtils.isAssignable(Short.class, Float.TYPE, true), "short -> float"); 985 assertTrue(ClassUtils.isAssignable(Short.class, Double.TYPE, true), "short -> double"); 986 assertFalse(ClassUtils.isAssignable(Short.class, Boolean.TYPE, true), "short -> boolean"); 987 988 // test char conversions 989 assertTrue(ClassUtils.isAssignable(Character.class, Character.TYPE, true), "char -> char"); 990 assertFalse(ClassUtils.isAssignable(Character.class, Byte.TYPE, true), "char -> byte"); 991 assertFalse(ClassUtils.isAssignable(Character.class, Short.TYPE, true), "char -> short"); 992 assertTrue(ClassUtils.isAssignable(Character.class, Integer.TYPE, true), "char -> int"); 993 assertTrue(ClassUtils.isAssignable(Character.class, Long.TYPE, true), "char -> long"); 994 assertTrue(ClassUtils.isAssignable(Character.class, Float.TYPE, true), "char -> float"); 995 assertTrue(ClassUtils.isAssignable(Character.class, Double.TYPE, true), "char -> double"); 996 assertFalse(ClassUtils.isAssignable(Character.class, Boolean.TYPE, true), "char -> boolean"); 997 998 // test int conversions 999 assertFalse(ClassUtils.isAssignable(Integer.class, Character.TYPE, true), "int -> char"); 1000 assertFalse(ClassUtils.isAssignable(Integer.class, Byte.TYPE, true), "int -> byte"); 1001 assertFalse(ClassUtils.isAssignable(Integer.class, Short.TYPE, true), "int -> short"); 1002 assertTrue(ClassUtils.isAssignable(Integer.class, Integer.TYPE, true), "int -> int"); 1003 assertTrue(ClassUtils.isAssignable(Integer.class, Long.TYPE, true), "int -> long"); 1004 assertTrue(ClassUtils.isAssignable(Integer.class, Float.TYPE, true), "int -> float"); 1005 assertTrue(ClassUtils.isAssignable(Integer.class, Double.TYPE, true), "int -> double"); 1006 assertFalse(ClassUtils.isAssignable(Integer.class, Boolean.TYPE, true), "int -> boolean"); 1007 1008 // test long conversions 1009 assertFalse(ClassUtils.isAssignable(Long.class, Character.TYPE, true), "long -> char"); 1010 assertFalse(ClassUtils.isAssignable(Long.class, Byte.TYPE, true), "long -> byte"); 1011 assertFalse(ClassUtils.isAssignable(Long.class, Short.TYPE, true), "long -> short"); 1012 assertFalse(ClassUtils.isAssignable(Long.class, Integer.TYPE, true), "long -> int"); 1013 assertTrue(ClassUtils.isAssignable(Long.class, Long.TYPE, true), "long -> long"); 1014 assertTrue(ClassUtils.isAssignable(Long.class, Float.TYPE, true), "long -> float"); 1015 assertTrue(ClassUtils.isAssignable(Long.class, Double.TYPE, true), "long -> double"); 1016 assertFalse(ClassUtils.isAssignable(Long.class, Boolean.TYPE, true), "long -> boolean"); 1017 1018 // test float conversions 1019 assertFalse(ClassUtils.isAssignable(Float.class, Character.TYPE, true), "float -> char"); 1020 assertFalse(ClassUtils.isAssignable(Float.class, Byte.TYPE, true), "float -> byte"); 1021 assertFalse(ClassUtils.isAssignable(Float.class, Short.TYPE, true), "float -> short"); 1022 assertFalse(ClassUtils.isAssignable(Float.class, Integer.TYPE, true), "float -> int"); 1023 assertFalse(ClassUtils.isAssignable(Float.class, Long.TYPE, true), "float -> long"); 1024 assertTrue(ClassUtils.isAssignable(Float.class, Float.TYPE, true), "float -> float"); 1025 assertTrue(ClassUtils.isAssignable(Float.class, Double.TYPE, true), "float -> double"); 1026 assertFalse(ClassUtils.isAssignable(Float.class, Boolean.TYPE, true), "float -> boolean"); 1027 1028 // test double conversions 1029 assertFalse(ClassUtils.isAssignable(Double.class, Character.TYPE, true), "double -> char"); 1030 assertFalse(ClassUtils.isAssignable(Double.class, Byte.TYPE, true), "double -> byte"); 1031 assertFalse(ClassUtils.isAssignable(Double.class, Short.TYPE, true), "double -> short"); 1032 assertFalse(ClassUtils.isAssignable(Double.class, Integer.TYPE, true), "double -> int"); 1033 assertFalse(ClassUtils.isAssignable(Double.class, Long.TYPE, true), "double -> long"); 1034 assertFalse(ClassUtils.isAssignable(Double.class, Float.TYPE, true), "double -> float"); 1035 assertTrue(ClassUtils.isAssignable(Double.class, Double.TYPE, true), "double -> double"); 1036 assertFalse(ClassUtils.isAssignable(Double.class, Boolean.TYPE, true), "double -> boolean"); 1037 1038 // test boolean conversions 1039 assertFalse(ClassUtils.isAssignable(Boolean.class, Character.TYPE, true), "boolean -> char"); 1040 assertFalse(ClassUtils.isAssignable(Boolean.class, Byte.TYPE, true), "boolean -> byte"); 1041 assertFalse(ClassUtils.isAssignable(Boolean.class, Short.TYPE, true), "boolean -> short"); 1042 assertFalse(ClassUtils.isAssignable(Boolean.class, Integer.TYPE, true), "boolean -> int"); 1043 assertFalse(ClassUtils.isAssignable(Boolean.class, Long.TYPE, true), "boolean -> long"); 1044 assertFalse(ClassUtils.isAssignable(Boolean.class, Float.TYPE, true), "boolean -> float"); 1045 assertFalse(ClassUtils.isAssignable(Boolean.class, Double.TYPE, true), "boolean -> double"); 1046 assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.TYPE, true), "boolean -> boolean"); 1047 } 1048 1049 @Test test_isAssignable_Widening()1050 public void test_isAssignable_Widening() { 1051 // test byte conversions 1052 assertFalse(ClassUtils.isAssignable(Byte.TYPE, Character.TYPE), "byte -> char"); 1053 assertTrue(ClassUtils.isAssignable(Byte.TYPE, Byte.TYPE), "byte -> byte"); 1054 assertTrue(ClassUtils.isAssignable(Byte.TYPE, Short.TYPE), "byte -> short"); 1055 assertTrue(ClassUtils.isAssignable(Byte.TYPE, Integer.TYPE), "byte -> int"); 1056 assertTrue(ClassUtils.isAssignable(Byte.TYPE, Long.TYPE), "byte -> long"); 1057 assertTrue(ClassUtils.isAssignable(Byte.TYPE, Float.TYPE), "byte -> float"); 1058 assertTrue(ClassUtils.isAssignable(Byte.TYPE, Double.TYPE), "byte -> double"); 1059 assertFalse(ClassUtils.isAssignable(Byte.TYPE, Boolean.TYPE), "byte -> boolean"); 1060 1061 // test short conversions 1062 assertFalse(ClassUtils.isAssignable(Short.TYPE, Character.TYPE), "short -> char"); 1063 assertFalse(ClassUtils.isAssignable(Short.TYPE, Byte.TYPE), "short -> byte"); 1064 assertTrue(ClassUtils.isAssignable(Short.TYPE, Short.TYPE), "short -> short"); 1065 assertTrue(ClassUtils.isAssignable(Short.TYPE, Integer.TYPE), "short -> int"); 1066 assertTrue(ClassUtils.isAssignable(Short.TYPE, Long.TYPE), "short -> long"); 1067 assertTrue(ClassUtils.isAssignable(Short.TYPE, Float.TYPE), "short -> float"); 1068 assertTrue(ClassUtils.isAssignable(Short.TYPE, Double.TYPE), "short -> double"); 1069 assertFalse(ClassUtils.isAssignable(Short.TYPE, Boolean.TYPE), "short -> boolean"); 1070 1071 // test char conversions 1072 assertTrue(ClassUtils.isAssignable(Character.TYPE, Character.TYPE), "char -> char"); 1073 assertFalse(ClassUtils.isAssignable(Character.TYPE, Byte.TYPE), "char -> byte"); 1074 assertFalse(ClassUtils.isAssignable(Character.TYPE, Short.TYPE), "char -> short"); 1075 assertTrue(ClassUtils.isAssignable(Character.TYPE, Integer.TYPE), "char -> int"); 1076 assertTrue(ClassUtils.isAssignable(Character.TYPE, Long.TYPE), "char -> long"); 1077 assertTrue(ClassUtils.isAssignable(Character.TYPE, Float.TYPE), "char -> float"); 1078 assertTrue(ClassUtils.isAssignable(Character.TYPE, Double.TYPE), "char -> double"); 1079 assertFalse(ClassUtils.isAssignable(Character.TYPE, Boolean.TYPE), "char -> boolean"); 1080 1081 // test int conversions 1082 assertFalse(ClassUtils.isAssignable(Integer.TYPE, Character.TYPE), "int -> char"); 1083 assertFalse(ClassUtils.isAssignable(Integer.TYPE, Byte.TYPE), "int -> byte"); 1084 assertFalse(ClassUtils.isAssignable(Integer.TYPE, Short.TYPE), "int -> short"); 1085 assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE), "int -> int"); 1086 assertTrue(ClassUtils.isAssignable(Integer.TYPE, Long.TYPE), "int -> long"); 1087 assertTrue(ClassUtils.isAssignable(Integer.TYPE, Float.TYPE), "int -> float"); 1088 assertTrue(ClassUtils.isAssignable(Integer.TYPE, Double.TYPE), "int -> double"); 1089 assertFalse(ClassUtils.isAssignable(Integer.TYPE, Boolean.TYPE), "int -> boolean"); 1090 1091 // test long conversions 1092 assertFalse(ClassUtils.isAssignable(Long.TYPE, Character.TYPE), "long -> char"); 1093 assertFalse(ClassUtils.isAssignable(Long.TYPE, Byte.TYPE), "long -> byte"); 1094 assertFalse(ClassUtils.isAssignable(Long.TYPE, Short.TYPE), "long -> short"); 1095 assertFalse(ClassUtils.isAssignable(Long.TYPE, Integer.TYPE), "long -> int"); 1096 assertTrue(ClassUtils.isAssignable(Long.TYPE, Long.TYPE), "long -> long"); 1097 assertTrue(ClassUtils.isAssignable(Long.TYPE, Float.TYPE), "long -> float"); 1098 assertTrue(ClassUtils.isAssignable(Long.TYPE, Double.TYPE), "long -> double"); 1099 assertFalse(ClassUtils.isAssignable(Long.TYPE, Boolean.TYPE), "long -> boolean"); 1100 1101 // test float conversions 1102 assertFalse(ClassUtils.isAssignable(Float.TYPE, Character.TYPE), "float -> char"); 1103 assertFalse(ClassUtils.isAssignable(Float.TYPE, Byte.TYPE), "float -> byte"); 1104 assertFalse(ClassUtils.isAssignable(Float.TYPE, Short.TYPE), "float -> short"); 1105 assertFalse(ClassUtils.isAssignable(Float.TYPE, Integer.TYPE), "float -> int"); 1106 assertFalse(ClassUtils.isAssignable(Float.TYPE, Long.TYPE), "float -> long"); 1107 assertTrue(ClassUtils.isAssignable(Float.TYPE, Float.TYPE), "float -> float"); 1108 assertTrue(ClassUtils.isAssignable(Float.TYPE, Double.TYPE), "float -> double"); 1109 assertFalse(ClassUtils.isAssignable(Float.TYPE, Boolean.TYPE), "float -> boolean"); 1110 1111 // test double conversions 1112 assertFalse(ClassUtils.isAssignable(Double.TYPE, Character.TYPE), "double -> char"); 1113 assertFalse(ClassUtils.isAssignable(Double.TYPE, Byte.TYPE), "double -> byte"); 1114 assertFalse(ClassUtils.isAssignable(Double.TYPE, Short.TYPE), "double -> short"); 1115 assertFalse(ClassUtils.isAssignable(Double.TYPE, Integer.TYPE), "double -> int"); 1116 assertFalse(ClassUtils.isAssignable(Double.TYPE, Long.TYPE), "double -> long"); 1117 assertFalse(ClassUtils.isAssignable(Double.TYPE, Float.TYPE), "double -> float"); 1118 assertTrue(ClassUtils.isAssignable(Double.TYPE, Double.TYPE), "double -> double"); 1119 assertFalse(ClassUtils.isAssignable(Double.TYPE, Boolean.TYPE), "double -> boolean"); 1120 1121 // test boolean conversions 1122 assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Character.TYPE), "boolean -> char"); 1123 assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Byte.TYPE), "boolean -> byte"); 1124 assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Short.TYPE), "boolean -> short"); 1125 assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Integer.TYPE), "boolean -> int"); 1126 assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Long.TYPE), "boolean -> long"); 1127 assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Float.TYPE), "boolean -> float"); 1128 assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Double.TYPE), "boolean -> double"); 1129 assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.TYPE), "boolean -> boolean"); 1130 } 1131 1132 @Test test_isInnerClass_Class()1133 public void test_isInnerClass_Class() { 1134 assertTrue(ClassUtils.isInnerClass(Inner.class)); 1135 assertTrue(ClassUtils.isInnerClass(Map.Entry.class)); 1136 assertTrue(ClassUtils.isInnerClass(new Cloneable() { 1137 // empty 1138 }.getClass())); 1139 assertFalse(ClassUtils.isInnerClass(this.getClass())); 1140 assertFalse(ClassUtils.isInnerClass(String.class)); 1141 assertFalse(ClassUtils.isInnerClass(null)); 1142 } 1143 1144 @Test testComparable()1145 public void testComparable() { 1146 final TreeMap<Class<?>, String> map = new TreeMap<>(ClassUtils.comparator()); 1147 map.put(String.class, "lastEntry"); 1148 map.toString(); 1149 map.put(Character.class, "firstEntry"); 1150 map.toString(); 1151 assertEquals("firstEntry", map.firstEntry().getValue()); 1152 assertEquals(Character.class, map.firstEntry().getKey()); 1153 // 1154 assertEquals("lastEntry", map.lastEntry().getValue()); 1155 assertEquals(String.class, map.lastEntry().getKey()); 1156 // 1157 map.put(null, "null"); 1158 map.toString(); 1159 assertEquals("null", map.get(null)); 1160 } 1161 1162 @Test testConstructor()1163 public void testConstructor() { 1164 assertNotNull(new ClassUtils()); 1165 final Constructor<?>[] cons = ClassUtils.class.getDeclaredConstructors(); 1166 assertEquals(1, cons.length); 1167 assertTrue(Modifier.isPublic(cons[0].getModifiers())); 1168 assertTrue(Modifier.isPublic(ClassUtils.class.getModifiers())); 1169 assertFalse(Modifier.isFinal(ClassUtils.class.getModifiers())); 1170 } 1171 1172 @Test testGetClassByNormalNameArrays()1173 public void testGetClassByNormalNameArrays() throws ClassNotFoundException { 1174 assertEquals(int[].class, ClassUtils.getClass("int[]")); 1175 assertEquals(long[].class, ClassUtils.getClass("long[]")); 1176 assertEquals(short[].class, ClassUtils.getClass("short[]")); 1177 assertEquals(byte[].class, ClassUtils.getClass("byte[]")); 1178 assertEquals(char[].class, ClassUtils.getClass("char[]")); 1179 assertEquals(float[].class, ClassUtils.getClass("float[]")); 1180 assertEquals(double[].class, ClassUtils.getClass("double[]")); 1181 assertEquals(boolean[].class, ClassUtils.getClass("boolean[]")); 1182 assertEquals(String[].class, ClassUtils.getClass("java.lang.String[]")); 1183 assertEquals(java.util.Map.Entry[].class, ClassUtils.getClass("java.util.Map.Entry[]")); 1184 assertEquals(java.util.Map.Entry[].class, ClassUtils.getClass("java.util.Map$Entry[]")); 1185 assertEquals(java.util.Map.Entry[].class, ClassUtils.getClass("[Ljava.util.Map.Entry;")); 1186 assertEquals(java.util.Map.Entry[].class, ClassUtils.getClass("[Ljava.util.Map$Entry;")); 1187 } 1188 1189 @Test testGetClassByNormalNameArrays2D()1190 public void testGetClassByNormalNameArrays2D() throws ClassNotFoundException { 1191 assertEquals(int[][].class, ClassUtils.getClass("int[][]")); 1192 assertEquals(long[][].class, ClassUtils.getClass("long[][]")); 1193 assertEquals(short[][].class, ClassUtils.getClass("short[][]")); 1194 assertEquals(byte[][].class, ClassUtils.getClass("byte[][]")); 1195 assertEquals(char[][].class, ClassUtils.getClass("char[][]")); 1196 assertEquals(float[][].class, ClassUtils.getClass("float[][]")); 1197 assertEquals(double[][].class, ClassUtils.getClass("double[][]")); 1198 assertEquals(boolean[][].class, ClassUtils.getClass("boolean[][]")); 1199 assertEquals(String[][].class, ClassUtils.getClass("java.lang.String[][]")); 1200 } 1201 1202 @Test testGetClassClassNotFound()1203 public void testGetClassClassNotFound() throws Exception { 1204 assertGetClassThrowsClassNotFound("bool"); 1205 assertGetClassThrowsClassNotFound("bool[]"); 1206 assertGetClassThrowsClassNotFound("integer[]"); 1207 } 1208 1209 @Test testGetClassInvalidArguments()1210 public void testGetClassInvalidArguments() throws Exception { 1211 assertGetClassThrowsNullPointerException(null); 1212 assertGetClassThrowsClassNotFound("[][][]"); 1213 assertGetClassThrowsClassNotFound("[[]"); 1214 assertGetClassThrowsClassNotFound("["); 1215 assertGetClassThrowsClassNotFound("java.lang.String]["); 1216 assertGetClassThrowsClassNotFound(".hello.world"); 1217 assertGetClassThrowsClassNotFound("hello..world"); 1218 } 1219 1220 @Test testGetClassRawPrimitives()1221 public void testGetClassRawPrimitives() throws ClassNotFoundException { 1222 assertEquals(int.class, ClassUtils.getClass("int")); 1223 assertEquals(long.class, ClassUtils.getClass("long")); 1224 assertEquals(short.class, ClassUtils.getClass("short")); 1225 assertEquals(byte.class, ClassUtils.getClass("byte")); 1226 assertEquals(char.class, ClassUtils.getClass("char")); 1227 assertEquals(float.class, ClassUtils.getClass("float")); 1228 assertEquals(double.class, ClassUtils.getClass("double")); 1229 assertEquals(boolean.class, ClassUtils.getClass("boolean")); 1230 assertEquals(void.class, ClassUtils.getClass("void")); 1231 } 1232 1233 @Test testGetClassWithArrayClasses()1234 public void testGetClassWithArrayClasses() throws Exception { 1235 assertGetClassReturnsClass(String[].class); 1236 assertGetClassReturnsClass(int[].class); 1237 assertGetClassReturnsClass(long[].class); 1238 assertGetClassReturnsClass(short[].class); 1239 assertGetClassReturnsClass(byte[].class); 1240 assertGetClassReturnsClass(char[].class); 1241 assertGetClassReturnsClass(float[].class); 1242 assertGetClassReturnsClass(double[].class); 1243 assertGetClassReturnsClass(boolean[].class); 1244 } 1245 1246 @Test testGetClassWithArrayClasses2D()1247 public void testGetClassWithArrayClasses2D() throws Exception { 1248 assertGetClassReturnsClass(String[][].class); 1249 assertGetClassReturnsClass(int[][].class); 1250 assertGetClassReturnsClass(long[][].class); 1251 assertGetClassReturnsClass(short[][].class); 1252 assertGetClassReturnsClass(byte[][].class); 1253 assertGetClassReturnsClass(char[][].class); 1254 assertGetClassReturnsClass(float[][].class); 1255 assertGetClassReturnsClass(double[][].class); 1256 assertGetClassReturnsClass(boolean[][].class); 1257 } 1258 1259 @Test testGetComponentType()1260 public void testGetComponentType() { 1261 final CX[] newArray = {}; 1262 @SuppressWarnings("unchecked") 1263 final Class<CX[]> classCxArray = (Class<CX[]>) newArray.getClass(); 1264 // No type-cast required. 1265 final Class<CX> componentType = ClassUtils.getComponentType(classCxArray); 1266 assertEquals(CX.class, componentType); 1267 assertNull(ClassUtils.getComponentType(null)); 1268 } 1269 1270 @Test testGetInnerClass()1271 public void testGetInnerClass() throws ClassNotFoundException { 1272 assertEquals(Inner.DeeplyNested.class, ClassUtils.getClass("org.apache.commons.lang3.ClassUtilsTest.Inner.DeeplyNested")); 1273 assertEquals(Inner.DeeplyNested.class, ClassUtils.getClass("org.apache.commons.lang3.ClassUtilsTest.Inner$DeeplyNested")); 1274 assertEquals(Inner.DeeplyNested.class, ClassUtils.getClass("org.apache.commons.lang3.ClassUtilsTest$Inner$DeeplyNested")); 1275 assertEquals(Inner.DeeplyNested.class, ClassUtils.getClass("org.apache.commons.lang3.ClassUtilsTest$Inner.DeeplyNested")); 1276 // 1277 assertEquals(Inner.DeeplyNested.class, ClassUtils.getClass("org.apache.commons.lang3.ClassUtilsTest.Inner.DeeplyNested", true)); 1278 assertEquals(Inner.DeeplyNested.class, ClassUtils.getClass("org.apache.commons.lang3.ClassUtilsTest.Inner$DeeplyNested", true)); 1279 assertEquals(Inner.DeeplyNested.class, ClassUtils.getClass("org.apache.commons.lang3.ClassUtilsTest$Inner$DeeplyNested", true)); 1280 assertEquals(Inner.DeeplyNested.class, ClassUtils.getClass("org.apache.commons.lang3.ClassUtilsTest$Inner.DeeplyNested", true)); 1281 // 1282 final ClassLoader classLoader = Inner.DeeplyNested.class.getClassLoader(); 1283 assertEquals(Inner.DeeplyNested.class, ClassUtils.getClass(classLoader, "org.apache.commons.lang3.ClassUtilsTest.Inner.DeeplyNested")); 1284 assertEquals(Inner.DeeplyNested.class, ClassUtils.getClass(classLoader, "org.apache.commons.lang3.ClassUtilsTest.Inner$DeeplyNested")); 1285 assertEquals(Inner.DeeplyNested.class, ClassUtils.getClass(classLoader, "org.apache.commons.lang3.ClassUtilsTest$Inner$DeeplyNested")); 1286 assertEquals(Inner.DeeplyNested.class, ClassUtils.getClass(classLoader, "org.apache.commons.lang3.ClassUtilsTest$Inner.DeeplyNested")); 1287 // 1288 } 1289 1290 @Test testGetPublicMethod()1291 public void testGetPublicMethod() throws Exception { 1292 // Tests with Collections$UnmodifiableSet 1293 final Set<?> set = Collections.unmodifiableSet(new HashSet<>()); 1294 final Method isEmptyMethod = ClassUtils.getPublicMethod(set.getClass(), "isEmpty"); 1295 assertTrue(Modifier.isPublic(isEmptyMethod.getDeclaringClass().getModifiers())); 1296 assertTrue((Boolean) isEmptyMethod.invoke(set)); 1297 1298 // Tests with a public Class 1299 final Method toStringMethod = ClassUtils.getPublicMethod(Object.class, "toString"); 1300 assertEquals(Object.class.getMethod("toString"), toStringMethod); 1301 } 1302 1303 @Test testHierarchyExcludingInterfaces()1304 public void testHierarchyExcludingInterfaces() { 1305 final Iterator<Class<?>> iter = ClassUtils.hierarchy(StringParameterizedChild.class).iterator(); 1306 assertEquals(StringParameterizedChild.class, iter.next()); 1307 assertEquals(GenericParent.class, iter.next()); 1308 assertEquals(Object.class, iter.next()); 1309 assertFalse(iter.hasNext()); 1310 } 1311 1312 @Test testHierarchyIncludingInterfaces()1313 public void testHierarchyIncludingInterfaces() { 1314 final Iterator<Class<?>> iter = ClassUtils.hierarchy(StringParameterizedChild.class, Interfaces.INCLUDE).iterator(); 1315 assertEquals(StringParameterizedChild.class, iter.next()); 1316 assertEquals(GenericParent.class, iter.next()); 1317 assertEquals(GenericConsumer.class, iter.next()); 1318 assertEquals(Object.class, iter.next()); 1319 assertFalse(iter.hasNext()); 1320 } 1321 1322 @Test testIsPrimitiveOrWrapper()1323 public void testIsPrimitiveOrWrapper() { 1324 1325 // test primitive wrapper classes 1326 assertTrue(ClassUtils.isPrimitiveOrWrapper(Boolean.class), "Boolean.class"); 1327 assertTrue(ClassUtils.isPrimitiveOrWrapper(Byte.class), "Byte.class"); 1328 assertTrue(ClassUtils.isPrimitiveOrWrapper(Character.class), "Character.class"); 1329 assertTrue(ClassUtils.isPrimitiveOrWrapper(Short.class), "Short.class"); 1330 assertTrue(ClassUtils.isPrimitiveOrWrapper(Integer.class), "Integer.class"); 1331 assertTrue(ClassUtils.isPrimitiveOrWrapper(Long.class), "Long.class"); 1332 assertTrue(ClassUtils.isPrimitiveOrWrapper(Double.class), "Double.class"); 1333 assertTrue(ClassUtils.isPrimitiveOrWrapper(Float.class), "Float.class"); 1334 1335 // test primitive classes 1336 assertTrue(ClassUtils.isPrimitiveOrWrapper(Boolean.TYPE), "boolean"); 1337 assertTrue(ClassUtils.isPrimitiveOrWrapper(Byte.TYPE), "byte"); 1338 assertTrue(ClassUtils.isPrimitiveOrWrapper(Character.TYPE), "char"); 1339 assertTrue(ClassUtils.isPrimitiveOrWrapper(Short.TYPE), "short"); 1340 assertTrue(ClassUtils.isPrimitiveOrWrapper(Integer.TYPE), "int"); 1341 assertTrue(ClassUtils.isPrimitiveOrWrapper(Long.TYPE), "long"); 1342 assertTrue(ClassUtils.isPrimitiveOrWrapper(Double.TYPE), "double"); 1343 assertTrue(ClassUtils.isPrimitiveOrWrapper(Float.TYPE), "float"); 1344 assertTrue(ClassUtils.isPrimitiveOrWrapper(Void.TYPE), "Void.TYPE"); 1345 1346 // others 1347 assertFalse(ClassUtils.isPrimitiveOrWrapper(null), "null"); 1348 assertFalse(ClassUtils.isPrimitiveOrWrapper(Void.class), "Void.class"); 1349 assertFalse(ClassUtils.isPrimitiveOrWrapper(String.class), "String.class"); 1350 assertFalse(ClassUtils.isPrimitiveOrWrapper(this.getClass()), "this.getClass()"); 1351 } 1352 1353 @Test testIsPrimitiveWrapper()1354 public void testIsPrimitiveWrapper() { 1355 1356 // test primitive wrapper classes 1357 assertTrue(ClassUtils.isPrimitiveWrapper(Boolean.class), "Boolean.class"); 1358 assertTrue(ClassUtils.isPrimitiveWrapper(Byte.class), "Byte.class"); 1359 assertTrue(ClassUtils.isPrimitiveWrapper(Character.class), "Character.class"); 1360 assertTrue(ClassUtils.isPrimitiveWrapper(Short.class), "Short.class"); 1361 assertTrue(ClassUtils.isPrimitiveWrapper(Integer.class), "Integer.class"); 1362 assertTrue(ClassUtils.isPrimitiveWrapper(Long.class), "Long.class"); 1363 assertTrue(ClassUtils.isPrimitiveWrapper(Double.class), "Double.class"); 1364 assertTrue(ClassUtils.isPrimitiveWrapper(Float.class), "Float.class"); 1365 1366 // test primitive classes 1367 assertFalse(ClassUtils.isPrimitiveWrapper(Boolean.TYPE), "boolean"); 1368 assertFalse(ClassUtils.isPrimitiveWrapper(Byte.TYPE), "byte"); 1369 assertFalse(ClassUtils.isPrimitiveWrapper(Character.TYPE), "char"); 1370 assertFalse(ClassUtils.isPrimitiveWrapper(Short.TYPE), "short"); 1371 assertFalse(ClassUtils.isPrimitiveWrapper(Integer.TYPE), "int"); 1372 assertFalse(ClassUtils.isPrimitiveWrapper(Long.TYPE), "long"); 1373 assertFalse(ClassUtils.isPrimitiveWrapper(Double.TYPE), "double"); 1374 assertFalse(ClassUtils.isPrimitiveWrapper(Float.TYPE), "float"); 1375 1376 // others 1377 assertFalse(ClassUtils.isPrimitiveWrapper(null), "null"); 1378 assertFalse(ClassUtils.isPrimitiveWrapper(Void.class), "Void.class"); 1379 assertFalse(ClassUtils.isPrimitiveWrapper(Void.TYPE), "Void.TYPE"); 1380 assertFalse(ClassUtils.isPrimitiveWrapper(String.class), "String.class"); 1381 assertFalse(ClassUtils.isPrimitiveWrapper(this.getClass()), "this.getClass()"); 1382 } 1383 1384 @Test testPrimitivesToWrappers()1385 public void testPrimitivesToWrappers() { 1386 // test null 1387 // assertNull("null -> null", ClassUtils.primitivesToWrappers(null)); // generates warning 1388 assertNull(ClassUtils.primitivesToWrappers((Class<?>[]) null), "null -> null"); // equivalent cast to avoid warning 1389 // Other possible casts for null 1390 assertArrayEquals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.primitivesToWrappers(), "empty -> empty"); 1391 final Class<?>[] castNull = ClassUtils.primitivesToWrappers((Class<?>) null); // == new Class<?>[]{null} 1392 assertArrayEquals(new Class<?>[] {null}, castNull, "(Class<?>) null -> [null]"); 1393 // test empty array is returned unchanged 1394 assertArrayEquals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.primitivesToWrappers(ArrayUtils.EMPTY_CLASS_ARRAY), "empty -> empty"); 1395 1396 // test an array of various classes 1397 final Class<?>[] primitives = new Class[] {Boolean.TYPE, Byte.TYPE, Character.TYPE, Short.TYPE, Integer.TYPE, Long.TYPE, Double.TYPE, Float.TYPE, 1398 String.class, ClassUtils.class}; 1399 final Class<?>[] wrappers = ClassUtils.primitivesToWrappers(primitives); 1400 1401 for (int i = 0; i < primitives.length; i++) { 1402 // test each returned wrapper 1403 final Class<?> primitive = primitives[i]; 1404 final Class<?> expectedWrapper = ClassUtils.primitiveToWrapper(primitive); 1405 1406 assertEquals(expectedWrapper, wrappers[i], primitive + " -> " + expectedWrapper); 1407 } 1408 1409 // test an array of no primitive classes 1410 final Class<?>[] noPrimitives = new Class[] {String.class, ClassUtils.class, Void.TYPE}; 1411 // This used to return the exact same array, but no longer does. 1412 assertNotSame(noPrimitives, ClassUtils.primitivesToWrappers(noPrimitives), "unmodified"); 1413 } 1414 1415 @Test testPrimitiveToWrapper()1416 public void testPrimitiveToWrapper() { 1417 1418 // test primitive classes 1419 assertEquals(Boolean.class, ClassUtils.primitiveToWrapper(Boolean.TYPE), "boolean -> Boolean.class"); 1420 assertEquals(Byte.class, ClassUtils.primitiveToWrapper(Byte.TYPE), "byte -> Byte.class"); 1421 assertEquals(Character.class, ClassUtils.primitiveToWrapper(Character.TYPE), "char -> Character.class"); 1422 assertEquals(Short.class, ClassUtils.primitiveToWrapper(Short.TYPE), "short -> Short.class"); 1423 assertEquals(Integer.class, ClassUtils.primitiveToWrapper(Integer.TYPE), "int -> Integer.class"); 1424 assertEquals(Long.class, ClassUtils.primitiveToWrapper(Long.TYPE), "long -> Long.class"); 1425 assertEquals(Double.class, ClassUtils.primitiveToWrapper(Double.TYPE), "double -> Double.class"); 1426 assertEquals(Float.class, ClassUtils.primitiveToWrapper(Float.TYPE), "float -> Float.class"); 1427 1428 // test a few other classes 1429 assertEquals(String.class, ClassUtils.primitiveToWrapper(String.class), "String.class -> String.class"); 1430 assertEquals(ClassUtils.class, ClassUtils.primitiveToWrapper(ClassUtils.class), "ClassUtils.class -> ClassUtils.class"); 1431 assertEquals(Void.TYPE, ClassUtils.primitiveToWrapper(Void.TYPE), "Void.TYPE -> Void.TYPE"); 1432 1433 // test null 1434 assertNull(ClassUtils.primitiveToWrapper(null), "null -> null"); 1435 } 1436 1437 // Show the Java bug: https://bugs.java.com/bugdatabase/view_bug.do?bug_id=4071957 1438 // We may have to delete this if a JDK fixes the bug. 1439 @Test testShowJavaBug()1440 public void testShowJavaBug() throws Exception { 1441 // Tests with Collections$UnmodifiableSet 1442 final Set<?> set = Collections.unmodifiableSet(new HashSet<>()); 1443 final Method isEmptyMethod = set.getClass().getMethod("isEmpty"); 1444 assertThrows(IllegalAccessException.class, () -> isEmptyMethod.invoke(set)); 1445 } 1446 1447 @Test testToClass_object()1448 public void testToClass_object() { 1449 // assertNull(ClassUtils.toClass(null)); // generates warning 1450 assertNull(ClassUtils.toClass((Object[]) null)); // equivalent explicit cast 1451 1452 // Additional varargs tests 1453 assertArrayEquals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.toClass(), "empty -> empty"); 1454 final Class<?>[] castNull = ClassUtils.toClass((Object) null); // == new Object[]{null} 1455 assertArrayEquals(new Object[] {null}, castNull, "(Object) null -> [null]"); 1456 1457 assertSame(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.toClass(ArrayUtils.EMPTY_OBJECT_ARRAY)); 1458 1459 assertArrayEquals(new Class[] {String.class, Integer.class, Double.class}, ClassUtils.toClass("Test", Integer.valueOf(1), Double.valueOf(99d))); 1460 1461 assertArrayEquals(new Class[] {String.class, null, Double.class}, ClassUtils.toClass("Test", null, Double.valueOf(99d))); 1462 } 1463 1464 @Test testWithInterleavingWhitespace()1465 public void testWithInterleavingWhitespace() throws ClassNotFoundException { 1466 assertEquals(int[].class, ClassUtils.getClass(" int [ ] ")); 1467 assertEquals(long[].class, ClassUtils.getClass("\rlong\t[\n]\r")); 1468 assertEquals(short[].class, ClassUtils.getClass("\tshort \t\t[]")); 1469 assertEquals(byte[].class, ClassUtils.getClass("byte[\t\t\n\r] ")); 1470 } 1471 1472 @Test testWrappersToPrimitives()1473 public void testWrappersToPrimitives() { 1474 // an array with classes to test 1475 final Class<?>[] classes = {Boolean.class, Byte.class, Character.class, Short.class, Integer.class, Long.class, Float.class, Double.class, String.class, 1476 ClassUtils.class, null}; 1477 1478 final Class<?>[] primitives = ClassUtils.wrappersToPrimitives(classes); 1479 // now test the result 1480 assertEquals(classes.length, primitives.length, "Wrong length of result array"); 1481 for (int i = 0; i < classes.length; i++) { 1482 final Class<?> expectedPrimitive = ClassUtils.wrapperToPrimitive(classes[i]); 1483 assertEquals(expectedPrimitive, primitives[i], classes[i] + " -> " + expectedPrimitive); 1484 } 1485 } 1486 1487 @Test testWrappersToPrimitivesEmpty()1488 public void testWrappersToPrimitivesEmpty() { 1489 final Class<?>[] empty = new Class[0]; 1490 assertArrayEquals(empty, ClassUtils.wrappersToPrimitives(empty), "Wrong result for empty input"); 1491 } 1492 1493 @Test testWrappersToPrimitivesNull()1494 public void testWrappersToPrimitivesNull() { 1495 // assertNull("Wrong result for null input", ClassUtils.wrappersToPrimitives(null)); // generates warning 1496 assertNull(ClassUtils.wrappersToPrimitives((Class<?>[]) null), "Wrong result for null input"); // equivalent cast 1497 // Other possible casts for null 1498 assertArrayEquals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.wrappersToPrimitives(), "empty -> empty"); 1499 final Class<?>[] castNull = ClassUtils.wrappersToPrimitives((Class<?>) null); // == new Class<?>[]{null} 1500 assertArrayEquals(new Class<?>[] {null}, castNull, "(Class<?>) null -> [null]"); 1501 } 1502 1503 @Test testWrapperToPrimitive()1504 public void testWrapperToPrimitive() { 1505 // an array with classes to convert 1506 final Class<?>[] primitives = {Boolean.TYPE, Byte.TYPE, Character.TYPE, Short.TYPE, Integer.TYPE, Long.TYPE, Float.TYPE, Double.TYPE}; 1507 for (final Class<?> primitive : primitives) { 1508 final Class<?> wrapperCls = ClassUtils.primitiveToWrapper(primitive); 1509 assertFalse(wrapperCls.isPrimitive(), "Still primitive"); 1510 assertEquals(primitive, ClassUtils.wrapperToPrimitive(wrapperCls), wrapperCls + " -> " + primitive); 1511 } 1512 } 1513 1514 @Test testWrapperToPrimitiveNoWrapper()1515 public void testWrapperToPrimitiveNoWrapper() { 1516 assertNull(ClassUtils.wrapperToPrimitive(String.class), "Wrong result for non wrapper class"); 1517 } 1518 1519 @Test testWrapperToPrimitiveNull()1520 public void testWrapperToPrimitiveNull() { 1521 assertNull(ClassUtils.wrapperToPrimitive(null), "Wrong result for null class"); 1522 } 1523 } 1524