KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > commons > lang > enums > EnumTest


1 /*
2  * Copyright 2002-2005 The Apache Software Foundation.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */

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 /**
37  * Test cases for the {@link Enum} class.
38  *
39  * @author Stephen Colebourne
40  * @author Gary D. Gregory
41  * @version $Id: EnumTest.java 179242 2005-05-31 17:48:08Z ggregory $
42  */

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     //-----------------------------------------------------------------------
265
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     //-----------------------------------------------------------------------
390
public void testNested() {
391         List list = new ArrayList(Nest.ColorEnum.getEnumList());
392         assertEquals(3, list.size()); // all is well
393
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         // This nesting works because the enum constants are defined in the SAME
398
// class as the getEnumList(). It just acts as a normal enum.
399
}
400
401     public void testNestedBroken() {
402         List list = new ArrayList(NestBroken.ColorEnum.getEnumList());
403         try {
404             assertEquals(0, list.size()); // no enums!!!
405
// this is BROKEN because the enum constants are defined in a DIFFERENT
406
// class from getEnumList(). Once NestBroken class is referenced,
407
// and thus class loaded with its enum constants, the getEnumList works:
408
} catch (AssertionFailedError ex) {
409             // this actually works and isn't broken on Linux SunJDK1.4.1, so...
410
assertEquals(3, list.size());
411         }
412         new NestBroken();
413         list = new ArrayList(NestBroken.ColorEnum.getEnumList());
414         assertEquals(3, list.size()); // all is well!!!
415
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()); // all is well
424
Iterator it = list.iterator();
425         assertSame(NestLinked.RED, it.next());
426         assertSame(NestLinked.GREEN, it.next());
427         assertSame(NestLinked.BLUE, it.next());
428         // This nesting works because a static block in the enum class forces a
429
// class load of the outer class which defines the enum constants.
430
}
431
432     public void testNestedReferenced() {
433         List list = new ArrayList(NestReferenced.ColorEnum.getEnumList());
434         assertEquals(3, list.size()); // all is well
435
Iterator it = list.iterator();
436         assertSame(NestReferenced.RED, it.next());
437         assertSame(NestReferenced.GREEN, it.next());
438         assertSame(NestReferenced.BLUE, it.next());
439         // This nesting works because the enum constants are actually defined in
440
// the SAME class as the getEnumList(). The references in the outer class
441
// are just extra references.
442
}
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         // Sanity checks:
454
assertTrue(colorEnum.equals(colorEnum));
455         assertNotNull(ColorEnum.class.getClassLoader());
456         // set up:
457
ClassLoader classLoader = ClassUtilsTest.newSystemClassLoader();
458         Object enumObjectFromOtherClassLoader = this.getColorEnum(classLoader, colorEnum.getName());
459         // the real test, part 1.
460
try {
461             ColorEnum testCase = (ColorEnum) enumObjectFromOtherClassLoader;
462             fail("Should have thrown a ClassCastException for " + testCase);
463         } catch (ClassCastException e) {
464             // normal.
465
}
466         // the real test, part 2.
467
assertEquals("The two objects should match even though they are from different class loaders", colorEnum,
468                 enumObjectFromOtherClassLoader);
469         // the real test, part 3.
470
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         // Sanity check:
484
ColorEnum.RED.equals(ColorEnum.RED);
485         assertNotNull(ColorEnum.class.getClassLoader());
486         // set up:
487
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             // Dump some information to help debug class loader issues under different JREs, Ant, Eclipse.
494
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