1 16 package org.apache.commons.lang.enums; 17 18 import java.lang.reflect.InvocationTargetException; 19 import java.lang.reflect.Method; 20 import java.net.URL; 21 import java.net.URLClassLoader; 22 import java.util.ArrayList; 23 import java.util.HashMap; 24 import java.util.Iterator; 25 import java.util.List; 26 import java.util.Map; 27 28 import junit.framework.AssertionFailedError; 29 import junit.framework.Test; 30 import junit.framework.TestCase; 31 import junit.framework.TestSuite; 32 import org.apache.commons.lang.ClassUtilsTest; 33 import org.apache.commons.lang.SerializationUtils; 34 import org.apache.commons.lang.enum.ColorEnum; 35 36 43 44 public final class EnumTest extends TestCase { 45 46 private static final String ENUMS_CLASS_NAME = "org.apache.commons.lang.enums.ColorEnum"; 47 48 public EnumTest(String name) { 49 super(name); 50 } 51 52 public void setUp() { 53 } 54 55 public static Test suite() { 56 TestSuite suite = new TestSuite(EnumTest.class); 57 suite.setName("Enum Tests"); 58 return suite; 59 } 60 61 public void testName() { 62 assertEquals("Red", ColorEnum.RED.getName()); 63 assertEquals("Green", ColorEnum.GREEN.getName()); 64 assertEquals("Blue", ColorEnum.BLUE.getName()); 65 } 66 67 public void testCompareTo() { 68 assertTrue(ColorEnum.BLUE.compareTo(ColorEnum.BLUE) == 0); 69 assertTrue(ColorEnum.RED.compareTo(ColorEnum.BLUE) > 0); 70 assertTrue(ColorEnum.BLUE.compareTo(ColorEnum.RED) < 0); 71 try { 72 ColorEnum.RED.compareTo(null); 73 fail(); 74 } catch (NullPointerException ex) {} 75 try { 76 ColorEnum.RED.compareTo(new Object()); 77 fail(); 78 } catch (ClassCastException ex) {} 79 } 80 81 public void testEquals() { 82 assertSame(ColorEnum.RED, ColorEnum.RED); 83 assertSame(ColorEnum.getEnum("Red"), ColorEnum.RED); 84 assertEquals(false, ColorEnum.RED.equals(null)); 85 assertEquals(true, ColorEnum.RED.equals(ColorEnum.RED)); 86 assertEquals(true, ColorEnum.RED.equals(ColorEnum.getEnum("Red"))); 87 } 88 89 public void testHashCode() { 90 assertEquals(ColorEnum.RED.hashCode(), ColorEnum.RED.hashCode()); 91 assertEquals(7 + ColorEnum.class.hashCode() + 3 * "Red".hashCode(), ColorEnum.RED.hashCode()); 92 } 93 94 public void testToString() { 95 String toString = ColorEnum.RED.toString(); 96 assertEquals("ColorEnum[Red]", toString); 97 assertSame(toString, ColorEnum.RED.toString()); 98 } 99 100 public void testIterator() { 101 Iterator it = ColorEnum.iterator(); 102 assertSame(ColorEnum.RED, it.next()); 103 assertSame(ColorEnum.GREEN, it.next()); 104 assertSame(ColorEnum.BLUE, it.next()); 105 } 106 107 public void testList() { 108 List list = new ArrayList(ColorEnum.getEnumList()); 109 110 assertNotNull(list); 111 112 assertEquals( list.size(), 113 ColorEnum.getEnumMap().keySet().size()); 114 115 Iterator it = list.iterator(); 116 assertSame(ColorEnum.RED, it.next()); 117 assertSame(ColorEnum.GREEN, it.next()); 118 assertSame(ColorEnum.BLUE, it.next()); 119 } 120 121 public void testMap() { 122 Map map = new HashMap(ColorEnum.getEnumMap()); 123 124 assertNotNull(map); 125 assertTrue(map.containsValue(ColorEnum.RED)); 126 assertTrue(map.containsValue(ColorEnum.GREEN)); 127 assertTrue(map.containsValue(ColorEnum.BLUE)); 128 assertSame(ColorEnum.RED, map.get("Red")); 129 assertSame(ColorEnum.GREEN, map.get("Green")); 130 assertSame(ColorEnum.BLUE, map.get("Blue")); 131 assertEquals( map.keySet().size(), 132 ColorEnum.getEnumList().size()); 133 } 134 135 public void testGet() { 136 assertSame(ColorEnum.RED, ColorEnum.getEnum("Red")); 137 assertSame(ColorEnum.GREEN, ColorEnum.getEnum("Green")); 138 assertSame(ColorEnum.BLUE, ColorEnum.getEnum("Blue")); 139 assertSame(null, ColorEnum.getEnum("Pink")); 140 } 141 142 public void testSerialization() { 143 int hashCode = ColorEnum.RED.hashCode(); 144 assertSame(ColorEnum.RED, SerializationUtils.clone(ColorEnum.RED)); 145 assertEquals(hashCode, SerializationUtils.clone(ColorEnum.RED).hashCode()); 146 assertSame(ColorEnum.GREEN, SerializationUtils.clone(ColorEnum.GREEN)); 147 assertSame(ColorEnum.BLUE, SerializationUtils.clone(ColorEnum.BLUE)); 148 } 149 150 public void testBroken1() { 151 try { 152 Broken1Enum.RED.getName(); 153 fail(); 154 } catch (ExceptionInInitializerError ex) { 155 assertTrue(ex.getException() instanceof IllegalArgumentException); 156 } 157 } 158 159 public void testBroken2() { 160 try { 161 Broken2Enum.RED.getName(); 162 fail(); 163 } catch (ExceptionInInitializerError ex) { 164 assertTrue(ex.getException() instanceof IllegalArgumentException); 165 } 166 } 167 168 public void testBroken3() { 169 try { 170 Broken3Enum.RED.getName(); 171 fail(); 172 } catch (ExceptionInInitializerError ex) { 173 assertTrue(ex.getException() instanceof IllegalArgumentException); 174 } 175 } 176 177 public void testBroken1Operation() { 178 try { 179 Broken1OperationEnum.PLUS.getName(); 180 fail(); 181 } catch (ExceptionInInitializerError ex) { 182 assertTrue(ex.getException() instanceof IllegalArgumentException); 183 } 184 } 185 186 public void testBroken2Operation() { 187 try { 188 Broken2OperationEnum.PLUS.getName(); 189 fail(); 190 } catch (ExceptionInInitializerError ex) { 191 assertTrue(ex.getException() instanceof IllegalArgumentException); 192 } 193 } 194 195 public void testBroken3Operation() { 196 try { 197 Broken3OperationEnum.PLUS.getName(); 198 fail(); 199 } catch (ExceptionInInitializerError ex) { 200 assertTrue(ex.getException() instanceof IllegalArgumentException); 201 } 202 } 203 204 public void testBroken4Operation() { 205 try { 206 Broken4OperationEnum.PLUS.getName(); 207 fail(); 208 } catch (ExceptionInInitializerError ex) { 209 assertTrue(ex.getException() instanceof IllegalArgumentException); 210 } 211 } 212 213 public void testBroken5Operation() { 214 try { 215 Broken5OperationEnum.PLUS.getName(); 216 fail(); 217 } catch (ExceptionInInitializerError ex) { 218 assertTrue(ex.getException() instanceof IllegalArgumentException); 219 } 220 } 221 222 public void testOperationGet() { 223 assertSame(OperationEnum.PLUS, OperationEnum.getEnum("Plus")); 224 assertSame(OperationEnum.MINUS, OperationEnum.getEnum("Minus")); 225 assertSame(null, OperationEnum.getEnum("Pink")); 226 } 227 228 public void testOperationSerialization() { 229 assertSame(OperationEnum.PLUS, SerializationUtils.clone(OperationEnum.PLUS)); 230 assertSame(OperationEnum.MINUS, SerializationUtils.clone(OperationEnum.MINUS)); 231 } 232 233 public void testOperationToString() { 234 assertEquals("OperationEnum[Plus]", OperationEnum.PLUS.toString()); 235 } 236 237 public void testOperationList() { 238 List list = OperationEnum.getEnumList(); 239 assertNotNull(list); 240 assertEquals(2, list.size()); 241 assertEquals(list.size(), OperationEnum.getEnumMap().keySet().size()); 242 243 Iterator it = list.iterator(); 244 assertSame(OperationEnum.PLUS, it.next()); 245 assertSame(OperationEnum.MINUS, it.next()); 246 } 247 248 public void testOperationMap() { 249 Map map = OperationEnum.getEnumMap(); 250 assertNotNull(map); 251 assertEquals(map.keySet().size(), OperationEnum.getEnumList().size()); 252 253 assertTrue(map.containsValue(OperationEnum.PLUS)); 254 assertTrue(map.containsValue(OperationEnum.MINUS)); 255 assertSame(OperationEnum.PLUS, map.get("Plus")); 256 assertSame(OperationEnum.MINUS, map.get("Minus")); 257 } 258 259 public void testOperationCalculation() { 260 assertEquals(3, OperationEnum.PLUS.eval(1, 2)); 261 assertEquals(-1, OperationEnum.MINUS.eval(1, 2)); 262 } 263 264 public void testExtended1Get() { 266 assertSame(Extended1Enum.ALPHA, Extended1Enum.getEnum("Alpha")); 267 assertSame(Extended1Enum.BETA, Extended1Enum.getEnum("Beta")); 268 assertSame(null, Extended1Enum.getEnum("Gamma")); 269 assertSame(null, Extended1Enum.getEnum("Delta")); 270 } 271 272 public void testExtended2Get() { 273 assertSame(Extended1Enum.ALPHA, Extended2Enum.ALPHA); 274 assertSame(Extended1Enum.BETA, Extended2Enum.BETA); 275 276 assertSame(Extended2Enum.ALPHA, Extended2Enum.getEnum("Alpha")); 277 assertSame(Extended2Enum.BETA, Extended2Enum.getEnum("Beta")); 278 assertSame(Extended2Enum.GAMMA, Extended2Enum.getEnum("Gamma")); 279 assertSame(null, Extended2Enum.getEnum("Delta")); 280 } 281 282 public void testExtended3Get() { 283 assertSame(Extended2Enum.ALPHA, Extended3Enum.ALPHA); 284 assertSame(Extended2Enum.BETA, Extended3Enum.BETA); 285 assertSame(Extended2Enum.GAMMA, Extended3Enum.GAMMA); 286 287 assertSame(Extended3Enum.ALPHA, Extended3Enum.getEnum("Alpha")); 288 assertSame(Extended3Enum.BETA, Extended3Enum.getEnum("Beta")); 289 assertSame(Extended3Enum.GAMMA, Extended3Enum.getEnum("Gamma")); 290 assertSame(Extended3Enum.DELTA, Extended3Enum.getEnum("Delta")); 291 } 292 293 public void testExtendedSerialization() { 294 assertSame(Extended1Enum.ALPHA, SerializationUtils.clone(Extended1Enum.ALPHA)); 295 assertSame(Extended1Enum.BETA, SerializationUtils.clone(Extended1Enum.BETA)); 296 assertSame(Extended2Enum.GAMMA, SerializationUtils.clone(Extended2Enum.GAMMA)); 297 assertSame(Extended3Enum.DELTA, SerializationUtils.clone(Extended3Enum.DELTA)); 298 } 299 300 public void testExtendedToString() { 301 assertEquals("Extended1Enum[Alpha]", Extended1Enum.ALPHA.toString()); 302 assertEquals("Extended1Enum[Beta]", Extended1Enum.BETA.toString()); 303 304 assertEquals("Extended1Enum[Alpha]", Extended2Enum.ALPHA.toString()); 305 assertEquals("Extended1Enum[Beta]", Extended2Enum.BETA.toString()); 306 assertEquals("Extended2Enum[Gamma]", Extended2Enum.GAMMA.toString()); 307 308 assertEquals("Extended1Enum[Alpha]", Extended3Enum.ALPHA.toString()); 309 assertEquals("Extended1Enum[Beta]", Extended3Enum.BETA.toString()); 310 assertEquals("Extended2Enum[Gamma]", Extended3Enum.GAMMA.toString()); 311 assertEquals("Extended3Enum[Delta]", Extended3Enum.DELTA.toString()); 312 } 313 314 public void testExtended1List() { 315 List list = Extended1Enum.getEnumList(); 316 assertNotNull(list); 317 assertEquals(2, list.size()); 318 assertEquals(list.size(), Extended1Enum.getEnumMap().keySet().size()); 319 320 Iterator it = list.iterator(); 321 assertSame(Extended1Enum.ALPHA, it.next()); 322 assertSame(Extended1Enum.BETA, it.next()); 323 } 324 325 public void testExtended2List() { 326 List list = Extended2Enum.getEnumList(); 327 assertNotNull(list); 328 assertEquals(3, list.size()); 329 assertEquals(list.size(), Extended2Enum.getEnumMap().keySet().size()); 330 331 Iterator it = list.iterator(); 332 assertSame(Extended2Enum.ALPHA, it.next()); 333 assertSame(Extended2Enum.BETA, it.next()); 334 assertSame(Extended2Enum.GAMMA, it.next()); 335 } 336 337 public void testExtended3List() { 338 List list = Extended3Enum.getEnumList(); 339 assertNotNull(list); 340 assertEquals(4, list.size()); 341 assertEquals(list.size(), Extended3Enum.getEnumMap().keySet().size()); 342 343 Iterator it = list.iterator(); 344 assertSame(Extended3Enum.ALPHA, it.next()); 345 assertSame(Extended3Enum.BETA, it.next()); 346 assertSame(Extended3Enum.GAMMA, it.next()); 347 assertSame(Extended3Enum.DELTA, it.next()); 348 } 349 350 public void testExtended1Map() { 351 Map map = Extended1Enum.getEnumMap(); 352 assertNotNull(map); 353 assertEquals(map.keySet().size(), Extended1Enum.getEnumList().size()); 354 355 assertTrue(map.containsValue(Extended1Enum.ALPHA)); 356 assertTrue(map.containsValue(Extended1Enum.BETA)); 357 assertSame(Extended1Enum.ALPHA, map.get("Alpha")); 358 assertSame(Extended1Enum.BETA, map.get("Beta")); 359 } 360 361 public void testExtended2Map() { 362 Map map = Extended2Enum.getEnumMap(); 363 assertNotNull(map); 364 assertEquals(map.keySet().size(), Extended2Enum.getEnumList().size()); 365 366 assertTrue(map.containsValue(Extended2Enum.ALPHA)); 367 assertTrue(map.containsValue(Extended2Enum.BETA)); 368 assertTrue(map.containsValue(Extended2Enum.GAMMA)); 369 assertSame(Extended2Enum.ALPHA, map.get("Alpha")); 370 assertSame(Extended2Enum.BETA, map.get("Beta")); 371 assertSame(Extended2Enum.GAMMA, map.get("Gamma")); 372 } 373 374 public void testExtended3Map() { 375 Map map = Extended3Enum.getEnumMap(); 376 assertNotNull(map); 377 assertEquals(map.keySet().size(), Extended3Enum.getEnumList().size()); 378 379 assertTrue(map.containsValue(Extended3Enum.ALPHA)); 380 assertTrue(map.containsValue(Extended3Enum.BETA)); 381 assertTrue(map.containsValue(Extended3Enum.GAMMA)); 382 assertTrue(map.containsValue(Extended3Enum.DELTA)); 383 assertSame(Extended3Enum.ALPHA, map.get("Alpha")); 384 assertSame(Extended3Enum.BETA, map.get("Beta")); 385 assertSame(Extended3Enum.GAMMA, map.get("Gamma")); 386 assertSame(Extended3Enum.DELTA, map.get("Delta")); 387 } 388 389 public void testNested() { 391 List list = new ArrayList(Nest.ColorEnum.getEnumList()); 392 assertEquals(3, list.size()); Iterator it = list.iterator(); 394 assertSame(Nest.ColorEnum.RED, it.next()); 395 assertSame(Nest.ColorEnum.GREEN, it.next()); 396 assertSame(Nest.ColorEnum.BLUE, it.next()); 397 } 400 401 public void testNestedBroken() { 402 List list = new ArrayList(NestBroken.ColorEnum.getEnumList()); 403 try { 404 assertEquals(0, list.size()); } catch (AssertionFailedError ex) { 409 assertEquals(3, list.size()); 411 } 412 new NestBroken(); 413 list = new ArrayList(NestBroken.ColorEnum.getEnumList()); 414 assertEquals(3, list.size()); Iterator it = list.iterator(); 416 assertSame(NestBroken.RED, it.next()); 417 assertSame(NestBroken.GREEN, it.next()); 418 assertSame(NestBroken.BLUE, it.next()); 419 } 420 421 public void testNestedLinked() { 422 List list = new ArrayList(NestLinked.ColorEnum.getEnumList()); 423 assertEquals(3, list.size()); Iterator it = list.iterator(); 425 assertSame(NestLinked.RED, it.next()); 426 assertSame(NestLinked.GREEN, it.next()); 427 assertSame(NestLinked.BLUE, it.next()); 428 } 431 432 public void testNestedReferenced() { 433 List list = new ArrayList(NestReferenced.ColorEnum.getEnumList()); 434 assertEquals(3, list.size()); Iterator it = list.iterator(); 436 assertSame(NestReferenced.RED, it.next()); 437 assertSame(NestReferenced.GREEN, it.next()); 438 assertSame(NestReferenced.BLUE, it.next()); 439 } 443 444 public void testColorEnumEqualsWithDifferentClassLoaders() throws SecurityException, IllegalArgumentException, 445 ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException { 446 this.testEqualsTrueWithDifferentClassLoaders(ColorEnum.BLUE); 447 this.testEqualsTrueWithDifferentClassLoaders(ColorEnum.GREEN); 448 this.testEqualsTrueWithDifferentClassLoaders(ColorEnum.RED); 449 } 450 451 void testEqualsTrueWithDifferentClassLoaders(ColorEnum colorEnum) throws ClassNotFoundException, SecurityException, 452 NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException { 453 assertTrue(colorEnum.equals(colorEnum)); 455 assertNotNull(ColorEnum.class.getClassLoader()); 456 ClassLoader classLoader = ClassUtilsTest.newSystemClassLoader(); 458 Object enumObjectFromOtherClassLoader = this.getColorEnum(classLoader, colorEnum.getName()); 459 try { 461 ColorEnum testCase = (ColorEnum) enumObjectFromOtherClassLoader; 462 fail("Should have thrown a ClassCastException for " + testCase); 463 } catch (ClassCastException e) { 464 } 466 assertEquals("The two objects should match even though they are from different class loaders", colorEnum, 468 enumObjectFromOtherClassLoader); 469 int falseCount = 0; 471 for (Iterator iter = ColorEnum.iterator(); iter.hasNext();) { 472 ColorEnum element = (ColorEnum) iter.next(); 473 if (!colorEnum.equals(element)) { 474 falseCount++; 475 assertFalse(enumObjectFromOtherClassLoader.equals(element)); 476 } 477 } 478 assertEquals(ColorEnum.getEnumList().size() - 1, falseCount); 479 } 480 481 Object getColorEnum(ClassLoader classLoader, String color) throws ClassNotFoundException, SecurityException, 482 NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException { 483 ColorEnum.RED.equals(ColorEnum.RED); 485 assertNotNull(ColorEnum.class.getClassLoader()); 486 assertNotNull(classLoader); 488 assertFalse(classLoader.equals(ColorEnum.class.getClassLoader())); 489 Class otherColorEnumClass = null; 490 try { 491 otherColorEnumClass = classLoader.loadClass(ENUMS_CLASS_NAME); 492 } catch (ClassNotFoundException e) { 493 System.err.println("Could not load " + ENUMS_CLASS_NAME + " from the class loader " + classLoader); 495 URLClassLoader urlCl = (URLClassLoader) classLoader; 496 URL[] urls = urlCl.getURLs(); 497 System.err.println("Class loader has " + urls.length + " URLs:"); 498 for (int i = 0; i < urls.length; i++) { 499 System.err.println("URL[" + i + "] = " + urls[i]); 500 } 501 e.printStackTrace(); 502 throw e; 503 } 504 assertNotNull(otherColorEnumClass); 505 assertNotNull(otherColorEnumClass.getClassLoader()); 506 assertTrue(classLoader.equals(otherColorEnumClass.getClassLoader())); 507 assertFalse(otherColorEnumClass.getClassLoader().equals(ColorEnum.class.getClassLoader())); 508 Method method = otherColorEnumClass.getMethod("getEnum", new Class[]{String.class}); 509 Object enumObject = method.invoke(otherColorEnumClass, new Object[]{color}); 510 assertNotNull(enumObject); 511 assertFalse(ColorEnum.class.equals(enumObject.getClass())); 512 assertFalse(ColorEnum.class == enumObject.getClass()); 513 return enumObject; 514 } 515 516 public void testEqualsToWrongInstance() { 517 for (Iterator iter = ColorEnum.iterator(); iter.hasNext();) { 518 ColorEnum element = (ColorEnum) iter.next(); 519 this.testEqualsToWrongInstance(element); 520 } 521 } 522 523 void testEqualsToWrongInstance(ColorEnum colorEnum) { 524 assertEquals(false, colorEnum.equals("test")); 525 assertEquals(false, colorEnum.equals(new Integer(1))); 526 assertEquals(false, colorEnum.equals(new Boolean(true))); 527 assertEquals(false, colorEnum.equals(new StringBuffer("test"))); 528 assertEquals(false, colorEnum.equals(new Object())); 529 assertEquals(false, colorEnum.equals(null)); 530 assertEquals(false, colorEnum.equals("")); 531 assertEquals(false, colorEnum.equals(ColorEnum.getEnum(null))); 532 assertEquals(false, colorEnum.equals(ColorEnum.getEnum(""))); 533 assertEquals(false, colorEnum.equals(ColorEnum.getEnum("This ColorEnum does not exist."))); 534 } 535 } 536 | Popular Tags |