1/* Licensed to the Apache Software Foundation (ASF) under one or more
2 * contributor license agreements.  See the NOTICE file distributed with
3 * this work for additional information regarding copyright ownership.
4 * The ASF licenses this file to You under the Apache License, Version 2.0
5 * (the "License"); you may not use this file except in compliance with
6 * the License.  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
17package org.apache.harmony.tests.java.util;
18
19import java.util.ArrayList;
20import java.util.Collection;
21import java.util.EnumSet;
22import java.util.Iterator;
23import java.util.NoSuchElementException;
24import java.util.Set;
25
26import junit.framework.TestCase;
27
28import org.apache.harmony.testframework.serialization.SerializationTest;
29
30public class EnumSetTest extends TestCase {
31    static final boolean disableRIBugs = true;
32
33    static enum EnumWithInnerClass {
34        a, b, c, d, e, f {
35        },
36    }
37
38    enum EnumWithAllInnerClass {
39        a {},
40        b {},
41    }
42
43    static enum EnumFoo {
44        a, b,c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, aa, bb, cc, dd, ee, ff, gg, hh, ii, jj, kk, ll,
45    }
46
47    static enum EmptyEnum {
48        // expected
49    }
50
51    static enum HugeEnumWithInnerClass {
52        a{}, b{}, c{}, d{}, e{}, f{}, g{}, h{}, i{}, j{}, k{}, l{}, m{}, n{}, o{}, p{}, q{}, r{}, s{}, t{}, u{}, v{}, w{}, x{}, y{}, z{}, A{}, B{}, C{}, D{}, E{}, F{}, G{}, H{}, I{}, J{}, K{}, L{}, M{}, N{}, O{}, P{}, Q{}, R{}, S{}, T{}, U{}, V{}, W{}, X{}, Y{}, Z{}, aa{}, bb{}, cc{}, dd{}, ee{}, ff{}, gg{}, hh{}, ii{}, jj{}, kk{}, ll{}, mm{},
53    }
54
55    static enum HugeEnum {
56        a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, aa, bb, cc, dd, ee, ff, gg, hh, ii, jj, kk, ll, mm,
57    }
58
59    static enum HugeEnumCount {
60        NO1, NO2, NO3, NO4, NO5, NO6, NO7, NO8, NO9, NO10, NO11, NO12, NO13, NO14, NO15, NO16, NO17, NO18, NO19, NO20,
61        NO21, NO22, NO23, NO24, NO25, NO26, NO27, NO28, NO29, NO30, NO31, NO32, NO33, NO34, NO35, NO36, NO37, NO38, NO39, NO40,
62        NO41, NO42, NO43, NO44, NO45, NO46, NO47, NO48, NO49, NO50, NO51, NO52, NO53, NO54, NO55, NO56, NO57, NO58, NO59, NO60,
63        NO61, NO62, NO63, NO64, NO65, NO66, NO67, NO68, NO69, NO70, NO71, NO72, NO73, NO74, NO75, NO76, NO77, NO78, NO79, NO80,
64        NO81, NO82, NO83, NO84, NO85, NO86, NO87, NO88, NO89, NO90, NO91, NO92, NO93, NO94, NO95, NO96, NO97, NO98, NO99, NO100,
65        NO101, NO102, NO103, NO104, NO105, NO106, NO107, NO108, NO109, NO110, NO111, NO112, NO113, NO114, NO115, NO116, NO117, NO118, NO119, NO120,
66        NO121, NO122, NO123, NO124, NO125, NO126, NO127, NO128, NO129, NO130,
67    }
68
69    /**
70     * java.util.EnumSet#noneOf(java.lang.Class)
71     */
72    @SuppressWarnings("unchecked")
73    public void test_NoneOf_LClass() {
74        try {
75            EnumSet.noneOf((Class) null);
76            fail("Should throw NullPointerException");
77        } catch (NullPointerException e) {
78            // expected
79        }
80
81        try {
82            EnumSet.noneOf(Enum.class);
83            fail("Should throw ClassCastException");
84        } catch (ClassCastException cce) {
85            // expected
86        }
87
88        Class<EnumWithAllInnerClass> c = (Class<EnumWithAllInnerClass>) EnumWithAllInnerClass.a
89                .getClass();
90        try {
91            EnumSet.noneOf(c);
92            fail("Should throw ClassCastException");
93        } catch (ClassCastException e) {
94            // expected
95        }
96
97        EnumSet<EnumWithAllInnerClass> setWithInnerClass = EnumSet
98                .noneOf(EnumWithAllInnerClass.class);
99        assertNotNull(setWithInnerClass);
100
101        // test enum type with more than 64 elements
102        Class<HugeEnumWithInnerClass> hc = (Class<HugeEnumWithInnerClass>) HugeEnumWithInnerClass.a
103            .getClass();
104        try {
105            EnumSet.noneOf(hc);
106            fail("Should throw ClassCastException");
107        } catch (ClassCastException e) {
108            // expected
109        }
110
111        EnumSet<HugeEnumWithInnerClass> hugeSetWithInnerClass = EnumSet
112            .noneOf(HugeEnumWithInnerClass.class);
113        assertNotNull(hugeSetWithInnerClass);
114    }
115
116    /**
117     * java.util.HugeEnumSet#iterator()
118     */
119    public void test_iterator_HugeEnumSet() {
120        EnumSet<HugeEnumCount> set;
121        Object[] array;
122
123        // Test HugeEnumSet with 65 elements
124        // which is more than the bits of Long
125        set = EnumSet.range(HugeEnumCount.NO1, HugeEnumCount.NO65);
126        array = set.toArray();
127        for (HugeEnumCount count : set) {
128            assertEquals(count, (HugeEnumCount) array[count.ordinal()]);
129        }
130
131        // Test HugeEnumSet with 130 elements
132        // which is more than twice of the bits of Long
133        set = EnumSet.range(HugeEnumCount.NO1, HugeEnumCount.NO130);
134        array = set.toArray();
135        for (HugeEnumCount count : set) {
136            assertEquals(count, (HugeEnumCount) array[count.ordinal()]);
137        }
138    }
139
140    public void testRemoveIteratorRemoveFromHugeEnumSet() {
141        EnumSet<HugeEnumCount> set = EnumSet.noneOf(HugeEnumCount.class);
142        set.add(HugeEnumCount.NO64);
143        set.add(HugeEnumCount.NO65);
144        set.add(HugeEnumCount.NO128);
145        Iterator<HugeEnumCount> iterator = set.iterator();
146        assertTrue(iterator.hasNext());
147        assertEquals(HugeEnumCount.NO64, iterator.next());
148        assertTrue(iterator.hasNext());
149        iterator.remove();
150        assertEquals(HugeEnumCount.NO65, iterator.next());
151        assertTrue(iterator.hasNext());
152        assertEquals(HugeEnumCount.NO128, iterator.next());
153        assertFalse(iterator.hasNext());
154        assertEquals(EnumSet.of(HugeEnumCount.NO65, HugeEnumCount.NO128), set);
155        iterator.remove();
156        assertEquals(EnumSet.of(HugeEnumCount.NO65), set);
157    }
158
159    /**
160     * java.util.EnumSet#allOf(java.lang.Class)
161     */
162    @SuppressWarnings("unchecked")
163    public void test_AllOf_LClass() {
164        try {
165            EnumSet.allOf((Class) null);
166            fail("Should throw NullPointerException");
167        } catch (NullPointerException e) {
168            // expected
169        }
170
171        try {
172            EnumSet.allOf(Enum.class);
173            fail("Should throw ClassCastException");
174        } catch (ClassCastException cce) {
175            // expected
176        }
177
178        EnumSet<EnumFoo> enumSet = EnumSet.allOf(EnumFoo.class);
179        assertEquals("Size of enumSet should be 64", 64, enumSet.size());
180
181        assertFalse(
182                "enumSet should not contain null value", enumSet.contains(null));
183        assertTrue(
184                "enumSet should contain EnumFoo.a", enumSet.contains(EnumFoo.a));
185        assertTrue(
186                "enumSet should contain EnumFoo.b", enumSet.contains(EnumFoo.b));
187
188        enumSet.add(EnumFoo.a);
189        assertEquals("Should be equal", 64, enumSet.size());
190
191        EnumSet<EnumFoo> anotherSet = EnumSet.allOf(EnumFoo.class);
192        assertEquals("Should be equal", enumSet, anotherSet);
193        assertNotSame("Should not be identical", enumSet, anotherSet);
194
195        // test enum with more than 64 elements
196        EnumSet<HugeEnum> hugeEnumSet = EnumSet.allOf(HugeEnum.class);
197        assertEquals(65, hugeEnumSet.size());
198
199        assertFalse(hugeEnumSet.contains(null));
200        assertTrue(hugeEnumSet.contains(HugeEnum.a));
201        assertTrue(hugeEnumSet.contains(HugeEnum.b));
202
203        hugeEnumSet.add(HugeEnum.a);
204        assertEquals(65, hugeEnumSet.size());
205
206        EnumSet<HugeEnum> anotherHugeSet = EnumSet.allOf(HugeEnum.class);
207        assertEquals(hugeEnumSet, anotherHugeSet);
208        assertNotSame(hugeEnumSet, anotherHugeSet);
209
210    }
211
212    /**
213     * java.util.EnumSet#add(E)
214     */
215    @SuppressWarnings("unchecked")
216    public void test_add_E() {
217        Set<EnumFoo> set = EnumSet.noneOf(EnumFoo.class);
218        set.add(EnumFoo.a);
219        set.add(EnumFoo.b);
220
221        try {
222            set.add(null);
223            fail("Should throw NullPointerException");
224        } catch (NullPointerException e) {
225            // expected
226        }
227
228        // test enum type with more than 64 elements
229        Set rawSet = set;
230        try {
231            rawSet.add(HugeEnumWithInnerClass.b);
232            fail("Should throw ClassCastException");
233        } catch (ClassCastException e) {
234            // expected
235        }
236
237        set.clear();
238        try {
239            set.add(null);
240            fail("Should throw NullPointerException");
241        } catch (NullPointerException e) {
242            // expected
243        }
244
245        boolean result = set.add(EnumFoo.a);
246        assertEquals("Size should be 1:", 1, set.size());
247        assertTrue("Return value should be true", result);
248
249        result = set.add(EnumFoo.a);
250        assertEquals("Size should be 1:", 1, set.size());
251        assertFalse("Return value should be false", result);
252
253        set.add(EnumFoo.b);
254        assertEquals("Size should be 2:", 2, set.size());
255
256        rawSet = set;
257        try {
258            rawSet.add(EnumWithAllInnerClass.a);
259            fail("Should throw ClassCastException");
260        } catch(ClassCastException e) {
261            // expected
262        }
263
264        try {
265            rawSet.add(EnumWithInnerClass.a);
266            fail("Should throw ClassCastException");
267        } catch(ClassCastException e) {
268            // expected
269        }
270
271        try {
272            rawSet.add(new Object());
273            fail("Should throw ClassCastException");
274        } catch(ClassCastException e) {
275            // expected
276        }
277
278        // test enum type with more than 64 elements
279        Set<HugeEnum> hugeSet = EnumSet.noneOf(HugeEnum.class);
280        result = hugeSet.add(HugeEnum.a);
281        assertTrue(result);
282
283        result = hugeSet.add(HugeEnum.a);
284        assertFalse(result);
285
286        try {
287            hugeSet.add(null);
288            fail("Should throw NullPointerException");
289        } catch (NullPointerException e) {
290            // expected
291        }
292
293        rawSet = hugeSet;
294        try {
295            rawSet.add(HugeEnumWithInnerClass.b);
296            fail("Should throw ClassCastException");
297        } catch (ClassCastException e) {
298            // expected
299        }
300
301        try {
302            rawSet.add(new Object());
303            fail("Should throw ClassCastException");
304        } catch (ClassCastException e) {
305            // expected
306        }
307
308        result = hugeSet.add(HugeEnum.mm);
309        assertTrue(result);
310        result = hugeSet.add(HugeEnum.mm);
311        assertFalse(result);
312        assertEquals(2, hugeSet.size());
313
314    }
315
316    /**
317     * java.util.EnumSet#addAll(Collection)
318     */
319    @SuppressWarnings( { "unchecked", "boxing" })
320    public void test_addAll_LCollection() {
321
322        Set<EnumFoo> set = EnumSet.noneOf(EnumFoo.class);
323        assertEquals("Size should be 0:", 0, set.size());
324
325        try {
326            set.addAll(null);
327            fail("Should throw NullPointerException");
328        } catch (NullPointerException e) {
329            // expected
330        }
331
332        Set emptySet = EnumSet.noneOf(EmptyEnum.class);
333        Enum[] elements = EmptyEnum.class.getEnumConstants();
334        for(int i = 0; i < elements.length; i++) {
335            emptySet.add(elements[i]);
336        }
337        boolean result = set.addAll(emptySet);
338        assertFalse(result);
339
340        Collection<EnumFoo> collection = new ArrayList<EnumFoo>();
341        collection.add(EnumFoo.a);
342        collection.add(EnumFoo.b);
343        result = set.addAll(collection);
344        assertTrue("addAll should be successful", result);
345        assertEquals("Size should be 2:", 2, set.size());
346
347        set = EnumSet.noneOf(EnumFoo.class);
348
349        Collection rawCollection = new ArrayList<Integer>();
350        result = set.addAll(rawCollection);
351        assertFalse(result);
352        rawCollection.add(1);
353        try {
354            set.addAll(rawCollection);
355            fail("Should throw ClassCastException");
356        } catch (ClassCastException e) {
357            // expected
358        }
359
360        Set<EnumFoo> fullSet = EnumSet.noneOf(EnumFoo.class);
361        fullSet.add(EnumFoo.a);
362        fullSet.add(EnumFoo.b);
363        result = set.addAll(fullSet);
364        assertTrue("addAll should be successful", result);
365        assertEquals("Size of set should be 2", 2, set.size());
366
367        try {
368            fullSet.addAll(null);
369            fail("Should throw NullPointerException");
370        } catch (NullPointerException e) {
371            // expected
372        }
373
374        Set fullSetWithSubclass = EnumSet.noneOf(EnumWithInnerClass.class);
375        elements = EnumWithInnerClass.class.getEnumConstants();
376        for(int i = 0; i < elements.length; i++) {
377            fullSetWithSubclass.add(elements[i]);
378        }
379        try {
380            set.addAll(fullSetWithSubclass);
381            fail("Should throw ClassCastException");
382        } catch (ClassCastException e) {
383            // expected
384        }
385        Set<EnumWithInnerClass> setWithSubclass = fullSetWithSubclass;
386        result = setWithSubclass.addAll(setWithSubclass);
387        assertFalse("Should return false", result);
388
389        Set<EnumWithInnerClass> anotherSetWithSubclass = EnumSet
390                .noneOf(EnumWithInnerClass.class);
391        elements = EnumWithInnerClass.class.getEnumConstants();
392        for(int i = 0; i < elements.length; i++) {
393            anotherSetWithSubclass.add((EnumWithInnerClass) elements[i]);
394        }
395        result = setWithSubclass.addAll(anotherSetWithSubclass);
396        assertFalse("Should return false", result);
397
398        anotherSetWithSubclass.remove(EnumWithInnerClass.a);
399        result = setWithSubclass.addAll(anotherSetWithSubclass);
400        assertFalse("Should return false", result);
401
402        // test enum type with more than 64 elements
403        Set<HugeEnum> hugeSet = EnumSet.noneOf(HugeEnum.class);
404        assertEquals(0, hugeSet.size());
405
406        try {
407            hugeSet.addAll(null);
408            fail("Should throw NullPointerException");
409        } catch (NullPointerException e) {
410            // expected
411        }
412
413        hugeSet = EnumSet.allOf(HugeEnum.class);
414        result = hugeSet.addAll(hugeSet);
415        assertFalse(result);
416
417        hugeSet = EnumSet.noneOf(HugeEnum.class);
418        Collection<HugeEnum> hugeCollection = new ArrayList<HugeEnum>();
419        hugeCollection.add(HugeEnum.a);
420        hugeCollection.add(HugeEnum.b);
421        result = hugeSet.addAll(hugeCollection);
422        assertTrue(result);
423        assertEquals(2, set.size());
424
425        hugeSet = EnumSet.noneOf(HugeEnum.class);
426
427        rawCollection = new ArrayList<Integer>();
428        result = hugeSet.addAll(rawCollection);
429        assertFalse(result);
430        rawCollection.add(1);
431        try {
432            hugeSet.addAll(rawCollection);
433            fail("Should throw ClassCastException");
434        } catch (ClassCastException e) {
435            // expected
436        }
437
438        EnumSet<HugeEnum> aHugeSet = EnumSet.noneOf(HugeEnum.class);
439        aHugeSet.add(HugeEnum.a);
440        aHugeSet.add(HugeEnum.b);
441        result = hugeSet.addAll(aHugeSet);
442        assertTrue(result);
443        assertEquals(2, hugeSet.size());
444
445        try {
446            aHugeSet.addAll(null);
447            fail("Should throw NullPointerException");
448        } catch (NullPointerException e) {
449            // expected
450        }
451
452        Set hugeSetWithSubclass = EnumSet.allOf(HugeEnumWithInnerClass.class);
453        try {
454            hugeSet.addAll(hugeSetWithSubclass);
455            fail("Should throw ClassCastException");
456        } catch (ClassCastException e) {
457            // expected
458        }
459        Set<HugeEnumWithInnerClass> hugeSetWithInnerSubclass = hugeSetWithSubclass;
460        result = hugeSetWithInnerSubclass.addAll(hugeSetWithInnerSubclass);
461        assertFalse(result);
462
463        Set<HugeEnumWithInnerClass> anotherHugeSetWithSubclass = EnumSet
464                .allOf(HugeEnumWithInnerClass.class);
465        result = hugeSetWithSubclass.addAll(anotherHugeSetWithSubclass);
466        assertFalse(result);
467
468        anotherHugeSetWithSubclass.remove(HugeEnumWithInnerClass.a);
469        result = setWithSubclass.addAll(anotherSetWithSubclass);
470        assertFalse(result);
471
472    }
473
474    /**
475     * java.util.EnumSet#remove(Object)
476     */
477    @SuppressWarnings("CollectionIncompatibleType")
478    public void test_remove_LOject() {
479        Set<EnumFoo> set = EnumSet.noneOf(EnumFoo.class);
480        Enum[] elements = EnumFoo.class.getEnumConstants();
481        for(int i = 0; i < elements.length; i++) {
482            set.add((EnumFoo) elements[i]);
483        }
484
485        boolean result = set.remove(null);
486        assertFalse("'set' does not contain null", result);
487
488        result = set.remove(EnumFoo.a);
489        assertTrue("Should return true", result);
490        result = set.remove(EnumFoo.a);
491        assertFalse("Should return false", result);
492
493        assertEquals("Size of set should be 63:", 63, set.size());
494
495        result = set.remove(EnumWithInnerClass.a);
496        assertFalse("Should return false", result);
497        result = set.remove(EnumWithInnerClass.f);
498        assertFalse("Should return false", result);
499
500        // test enum with more than 64 elements
501        Set<HugeEnum> hugeSet = EnumSet.allOf(HugeEnum.class);
502
503        result = hugeSet.remove(null);
504        assertFalse("'set' does not contain null", result);
505
506        result = hugeSet.remove(HugeEnum.a);
507        assertTrue("Should return true", result);
508        result = hugeSet.remove(HugeEnum.a);
509        assertFalse("Should return false", result);
510
511        assertEquals("Size of set should be 64:", 64, hugeSet.size());
512
513        result = hugeSet.remove(HugeEnumWithInnerClass.a);
514        assertFalse("Should return false", result);
515        result = hugeSet.remove(HugeEnumWithInnerClass.f);
516        assertFalse("Should return false", result);
517    }
518
519    /**
520     * java.util.EnumSet#equals(Object)
521     */
522    public void test_equals_LObject() {
523        Set<EnumFoo> set = EnumSet.noneOf(EnumFoo.class);
524        Enum[] elements = EnumFoo.class.getEnumConstants();
525        for(int i = 0; i < elements.length; i++) {
526            set.add((EnumFoo) elements[i]);
527        }
528
529        assertFalse("Should return false", set.equals(null));
530        assertFalse(
531                "Should return false", set.equals(new Object()));
532
533        Set<EnumFoo> anotherSet = EnumSet.noneOf(EnumFoo.class);
534        elements = EnumFoo.class.getEnumConstants();
535        for(int i = 0; i < elements.length; i++) {
536            anotherSet.add((EnumFoo) elements[i]);
537        }
538        assertTrue("Should return true", set.equals(anotherSet));
539
540        anotherSet.remove(EnumFoo.a);
541        assertFalse(
542                "Should return false", set.equals(anotherSet));
543
544        Set<EnumWithInnerClass> setWithInnerClass = EnumSet
545                .noneOf(EnumWithInnerClass.class);
546        elements = EnumWithInnerClass.class.getEnumConstants();
547        for(int i = 0; i < elements.length; i++) {
548            setWithInnerClass.add((EnumWithInnerClass) elements[i]);
549        }
550
551        assertFalse(
552                "Should return false", set.equals(setWithInnerClass));
553
554        setWithInnerClass.clear();
555        set.clear();
556        assertTrue("Should be equal", set.equals(setWithInnerClass));
557
558        // test enum type with more than 64 elements
559        Set<HugeEnum> hugeSet = EnumSet.noneOf(HugeEnum.class);
560        assertTrue(hugeSet.equals(set));
561
562        hugeSet = EnumSet.allOf(HugeEnum.class);
563        assertFalse(hugeSet.equals(null));
564        assertFalse(hugeSet.equals(new Object()));
565
566        Set<HugeEnum> anotherHugeSet = EnumSet.allOf(HugeEnum.class);
567        anotherHugeSet.remove(HugeEnum.a);
568        assertFalse(hugeSet.equals(anotherHugeSet));
569
570        Set<HugeEnumWithInnerClass> hugeSetWithInnerClass = EnumSet
571                .allOf(HugeEnumWithInnerClass.class);
572        assertFalse(hugeSet.equals(hugeSetWithInnerClass));
573        hugeSetWithInnerClass.clear();
574        hugeSet.clear();
575        assertTrue(hugeSet.equals(hugeSetWithInnerClass));
576    }
577
578    /**
579     * java.util.EnumSet#clear()
580     */
581    public void test_clear() {
582        Set<EnumFoo> set = EnumSet.noneOf(EnumFoo.class);
583        set.add(EnumFoo.a);
584        set.add(EnumFoo.b);
585        assertEquals("Size should be 2", 2, set.size());
586
587        set.clear();
588
589        assertEquals("Size should be 0", 0, set.size());
590
591        // test enum type with more than 64 elements
592        Set<HugeEnum> hugeSet = EnumSet.allOf(HugeEnum.class);
593        assertEquals(65, hugeSet.size());
594
595        boolean result = hugeSet.contains(HugeEnum.aa);
596        assertTrue(result);
597
598        hugeSet.clear();
599        assertEquals(0, hugeSet.size());
600        result = hugeSet.contains(HugeEnum.aa);
601        assertFalse(result);
602    }
603
604    /**
605     * java.util.EnumSet#size()
606     */
607    public void test_size() {
608        Set<EnumFoo> set = EnumSet.noneOf(EnumFoo.class);
609        set.add(EnumFoo.a);
610        set.add(EnumFoo.b);
611        assertEquals("Size should be 2", 2, set.size());
612
613        // test enum type with more than 64 elements
614        Set<HugeEnum> hugeSet = EnumSet.noneOf(HugeEnum.class);
615        hugeSet.add(HugeEnum.a);
616        hugeSet.add(HugeEnum.bb);
617        assertEquals("Size should be 2", 2, hugeSet.size());
618    }
619
620    /**
621     * java.util.EnumSet#complementOf(java.util.EnumSet)
622     */
623    public void test_ComplementOf_LEnumSet() {
624
625        try {
626            EnumSet.complementOf((EnumSet<EnumFoo>) null);
627            fail("Should throw NullPointerException");
628        } catch (NullPointerException npe) {
629            // expected
630        }
631
632        EnumSet<EnumWithInnerClass> set = EnumSet
633                .noneOf(EnumWithInnerClass.class);
634        set.add(EnumWithInnerClass.d);
635        set.add(EnumWithInnerClass.e);
636        set.add(EnumWithInnerClass.f);
637
638        assertEquals("Size should be 3:", 3, set.size());
639
640        EnumSet<EnumWithInnerClass> complementOfE = EnumSet.complementOf(set);
641        assertTrue(set.contains(EnumWithInnerClass.d));
642        assertEquals(
643                "complementOfE should have size 3", 3, complementOfE.size());
644        assertTrue("complementOfE should contain EnumWithSubclass.a:",
645                complementOfE.contains(EnumWithInnerClass.a));
646        assertTrue("complementOfE should contain EnumWithSubclass.b:",
647                complementOfE.contains(EnumWithInnerClass.b));
648        assertTrue("complementOfE should contain EnumWithSubclass.c:",
649                complementOfE.contains(EnumWithInnerClass.c));
650
651        // test enum type with more than 64 elements
652        EnumSet<HugeEnum> hugeSet = EnumSet.noneOf(HugeEnum.class);
653        assertEquals(0, hugeSet.size());
654        Set<HugeEnum> complementHugeSet = EnumSet.complementOf(hugeSet);
655        assertEquals(65, complementHugeSet.size());
656
657        hugeSet.add(HugeEnum.A);
658        hugeSet.add(HugeEnum.mm);
659        complementHugeSet = EnumSet.complementOf(hugeSet);
660        assertEquals(63, complementHugeSet.size());
661
662        try {
663            EnumSet.complementOf((EnumSet<HugeEnum>) null);
664            fail("Should throw NullPointerException");
665        } catch (NullPointerException npe) {
666            // expected
667        }
668    }
669
670    /**
671     * java.util.EnumSet#contains(Object)
672     */
673    @SuppressWarnings("CollectionIncompatibleType")
674    public void test_contains_LObject() {
675        Set<EnumFoo> set = EnumSet.noneOf(EnumFoo.class);
676        Enum[] elements = EnumFoo.class.getEnumConstants();
677        for(int i = 0; i < elements.length; i++) {
678            set.add((EnumFoo)elements[i]);
679        }
680        boolean result = set.contains(null);
681        assertFalse("Should not contain null:", result);
682
683        result = set.contains(EnumFoo.a);
684        assertTrue("Should contain EnumFoo.a", result);
685        result = set.contains(EnumFoo.ll);
686        assertTrue("Should contain EnumFoo.ll", result);
687
688        result = set.contains(EnumFoo.b);
689        assertTrue("Should contain EnumFoo.b", result);
690
691        result = set.contains(new Object());
692        assertFalse("Should not contain Object instance", result);
693
694        result = set.contains(EnumWithInnerClass.a);
695        assertFalse("Should not contain EnumWithSubclass.a", result);
696
697        set = EnumSet.noneOf(EnumFoo.class);
698        set.add(EnumFoo.aa);
699        set.add(EnumFoo.bb);
700        set.add(EnumFoo.cc);
701
702        assertEquals("Size of set should be 3", 3, set.size());
703        assertTrue("set should contain EnumFoo.aa", set.contains(EnumFoo.aa));
704
705        Set<EnumWithInnerClass> setWithSubclass = EnumSet
706                .noneOf(EnumWithInnerClass.class);
707        setWithSubclass.add(EnumWithInnerClass.a);
708        setWithSubclass.add(EnumWithInnerClass.b);
709        setWithSubclass.add(EnumWithInnerClass.c);
710        setWithSubclass.add(EnumWithInnerClass.d);
711        setWithSubclass.add(EnumWithInnerClass.e);
712        setWithSubclass.add(EnumWithInnerClass.f);
713        result = setWithSubclass.contains(EnumWithInnerClass.f);
714        assertTrue("Should contain EnumWithSubclass.f", result);
715
716        // test enum type with more than 64 elements
717        Set<HugeEnum> hugeSet = EnumSet.allOf(HugeEnum.class);
718        hugeSet.add(HugeEnum.a);
719        result = hugeSet.contains(HugeEnum.a);
720        assertTrue(result);
721
722        result = hugeSet.contains(HugeEnum.b);
723        assertTrue(result);
724
725        result = hugeSet.contains(null);
726        assertFalse(result);
727
728        result = hugeSet.contains(HugeEnum.a);
729        assertTrue(result);
730
731        result = hugeSet.contains(HugeEnum.ll);
732        assertTrue(result);
733
734        result = hugeSet.contains(new Object());
735        assertFalse(result);
736
737        result = hugeSet.contains(Enum.class);
738        assertFalse(result);
739
740    }
741
742    /**
743     * java.util.EnumSet#containsAll(Collection)
744     */
745    @SuppressWarnings( { "unchecked", "boxing", "CollectionIncompatibleType" })
746    public void test_containsAll_LCollection() {
747        EnumSet<EnumFoo> set = EnumSet.noneOf(EnumFoo.class);
748        Enum[] elements = EnumFoo.class.getEnumConstants();
749        for(int i = 0; i < elements.length; i++) {
750            set.add((EnumFoo)elements[i]);
751        }
752        try {
753            set.containsAll(null);
754            fail("Should throw NullPointerException");
755        } catch (NullPointerException e) {
756            // expected
757        }
758
759        EnumSet<EmptyEnum> emptySet = EnumSet.noneOf(EmptyEnum.class);
760        elements = EmptyEnum.class.getEnumConstants();
761        for(int i = 0; i < elements.length; i++) {
762            emptySet.add((EmptyEnum)elements[i]);
763        }
764        boolean result = set.containsAll(emptySet);
765        assertTrue("Should return true", result);
766
767        Collection rawCollection = new ArrayList();
768        result = set.containsAll(rawCollection);
769        assertTrue("Should contain empty collection:", result);
770
771        rawCollection.add(1);
772        result = set.containsAll(rawCollection);
773        assertFalse("Should return false", result);
774
775        rawCollection.add(EnumWithInnerClass.a);
776        result = set.containsAll(rawCollection);
777        assertFalse("Should return false", result);
778
779        EnumSet rawSet = EnumSet.noneOf(EnumFoo.class);
780        result = set.containsAll(rawSet);
781        assertTrue("Should contain empty set", result);
782
783        emptySet = EnumSet.noneOf(EmptyEnum.class);
784        result = set.containsAll(emptySet);
785        assertTrue("No class cast should be performed on empty set", result);
786
787        Collection<EnumFoo> collection = new ArrayList<EnumFoo>();
788        collection.add(EnumFoo.a);
789        result = set.containsAll(collection);
790        assertTrue("Should contain all elements in collection", result);
791
792        EnumSet<EnumFoo> fooSet = EnumSet.noneOf(EnumFoo.class);
793        fooSet.add(EnumFoo.a);
794        result = set.containsAll(fooSet);
795        assertTrue("Should return true", result);
796
797        set.clear();
798        try {
799            set.containsAll(null);
800            fail("Should throw NullPointerException");
801        } catch (NullPointerException e) {
802            // expected
803        }
804
805        Collection<EnumWithInnerClass> collectionWithSubclass = new ArrayList<EnumWithInnerClass>();
806        collectionWithSubclass.add(EnumWithInnerClass.a);
807        result = set.containsAll(collectionWithSubclass);
808        assertFalse("Should return false", result);
809
810        EnumSet<EnumWithInnerClass> setWithSubclass = EnumSet
811                .noneOf(EnumWithInnerClass.class);
812        setWithSubclass.add(EnumWithInnerClass.a);
813        result = set.containsAll(setWithSubclass);
814        assertFalse("Should return false", result);
815
816        // test enum type with more than 64 elements
817        Set<HugeEnum> hugeSet = EnumSet.noneOf(HugeEnum.class);
818        hugeSet.add(HugeEnum.a);
819        hugeSet.add(HugeEnum.b);
820        hugeSet.add(HugeEnum.aa);
821        hugeSet.add(HugeEnum.bb);
822        hugeSet.add(HugeEnum.cc);
823        hugeSet.add(HugeEnum.dd);
824
825        Set<HugeEnum> anotherHugeSet = EnumSet.noneOf(HugeEnum.class);
826        hugeSet.add(HugeEnum.b);
827        hugeSet.add(HugeEnum.cc);
828        result = hugeSet.containsAll(anotherHugeSet);
829        assertTrue(result);
830
831        try {
832            hugeSet.containsAll(null);
833            fail("Should throw NullPointerException");
834        } catch(NullPointerException e) {
835            // expected
836        }
837
838        Set<HugeEnumWithInnerClass> hugeSetWithInnerClass = EnumSet
839                .noneOf(HugeEnumWithInnerClass.class);
840        hugeSetWithInnerClass.add(HugeEnumWithInnerClass.a);
841        hugeSetWithInnerClass.add(HugeEnumWithInnerClass.b);
842        result = hugeSetWithInnerClass.containsAll(hugeSetWithInnerClass);
843        assertTrue(result);
844        result = hugeSet.containsAll(hugeSetWithInnerClass);
845        assertFalse(result);
846
847        rawCollection = new ArrayList();
848        result = hugeSet.containsAll(rawCollection);
849        assertTrue("Should contain empty collection:", result);
850
851        rawCollection.add(1);
852        result = hugeSet.containsAll(rawCollection);
853        assertFalse("Should return false", result);
854
855        rawCollection.add(EnumWithInnerClass.a);
856        result = set.containsAll(rawCollection);
857        assertFalse("Should return false", result);
858
859        rawSet = EnumSet.noneOf(HugeEnum.class);
860        result = hugeSet.containsAll(rawSet);
861        assertTrue("Should contain empty set", result);
862
863        EnumSet<HugeEnumWithInnerClass> emptyHugeSet
864            = EnumSet.noneOf(HugeEnumWithInnerClass.class);
865        result = hugeSet.containsAll(emptyHugeSet);
866        assertTrue("No class cast should be performed on empty set", result);
867
868        Collection<HugeEnum> hugeCollection = new ArrayList<HugeEnum>();
869        hugeCollection.add(HugeEnum.a);
870        result = hugeSet.containsAll(hugeCollection);
871        assertTrue("Should contain all elements in collection", result);
872
873        hugeSet.clear();
874        try {
875            hugeSet.containsAll(null);
876            fail("Should throw NullPointerException");
877        } catch (NullPointerException e) {
878            // expected
879        }
880
881        Collection<HugeEnumWithInnerClass> hugeCollectionWithSubclass = new ArrayList<HugeEnumWithInnerClass>();
882        hugeCollectionWithSubclass.add(HugeEnumWithInnerClass.a);
883        result = hugeSet.containsAll(hugeCollectionWithSubclass);
884        assertFalse("Should return false", result);
885
886        EnumSet<HugeEnumWithInnerClass> hugeSetWithSubclass = EnumSet
887                .noneOf(HugeEnumWithInnerClass.class);
888        hugeSetWithSubclass.add(HugeEnumWithInnerClass.a);
889        result = hugeSet.containsAll(hugeSetWithSubclass);
890        assertFalse("Should return false", result);
891    }
892
893    /**
894     * java.util.EnumSet#copyOf(java.util.Collection)
895     */
896    @SuppressWarnings("unchecked")
897    public void test_CopyOf_LCollection() {
898        try {
899            EnumSet.copyOf((Collection) null);
900            fail("Should throw NullPointerException");
901        } catch (NullPointerException npe) {
902            // expected
903        }
904
905        Collection collection = new ArrayList();
906        try {
907            EnumSet.copyOf(collection);
908            fail("Should throw IllegalArgumentException");
909        } catch (IllegalArgumentException e) {
910            // expected
911        }
912
913        collection.add(new Object());
914        try {
915            EnumSet.copyOf(collection);
916            fail("Should throw ClassCastException");
917        } catch (ClassCastException e) {
918            // expected
919        }
920
921        Collection<EnumFoo> enumCollection = new ArrayList<EnumFoo>();
922        enumCollection.add(EnumFoo.b);
923
924        EnumSet<EnumFoo> copyOfEnumCollection = EnumSet.copyOf(enumCollection);
925        assertEquals("Size of copyOfEnumCollection should be 1:",
926                1, copyOfEnumCollection.size());
927        assertTrue("copyOfEnumCollection should contain EnumFoo.b:",
928                copyOfEnumCollection.contains(EnumFoo.b));
929
930        enumCollection.add(null);
931        assertEquals("Size of enumCollection should be 2:",
932                2, enumCollection.size());
933
934        try {
935            copyOfEnumCollection = EnumSet.copyOf(enumCollection);
936            fail("Should throw NullPointerException");
937        } catch (NullPointerException npe) {
938            // expected
939        }
940
941        Collection rawEnumCollection = new ArrayList();
942        rawEnumCollection.add(EnumFoo.a);
943        rawEnumCollection.add(EnumWithInnerClass.a);
944        try {
945            EnumSet.copyOf(rawEnumCollection);
946            fail("Should throw ClassCastException");
947        } catch(ClassCastException e) {
948            // expected
949        }
950
951        // test enum type with more than 64 elements
952        Collection<HugeEnum> hugeEnumCollection = new ArrayList<HugeEnum>();
953        hugeEnumCollection.add(HugeEnum.b);
954
955        EnumSet<HugeEnum> copyOfHugeEnumCollection = EnumSet.copyOf(hugeEnumCollection);
956        assertEquals(1, copyOfHugeEnumCollection.size());
957        assertTrue(copyOfHugeEnumCollection.contains(HugeEnum.b));
958
959        hugeEnumCollection.add(null);
960        assertEquals(2, hugeEnumCollection.size());
961
962        try {
963            copyOfHugeEnumCollection = EnumSet.copyOf(hugeEnumCollection);
964            fail("Should throw NullPointerException");
965        } catch (NullPointerException npe) {
966            // expected
967        }
968
969        rawEnumCollection = new ArrayList();
970        rawEnumCollection.add(HugeEnum.a);
971        rawEnumCollection.add(HugeEnumWithInnerClass.a);
972        try {
973            EnumSet.copyOf(rawEnumCollection);
974            fail("Should throw ClassCastException");
975        } catch(ClassCastException e) {
976            // expected
977        }
978    }
979
980    /**
981     * java.util.EnumSet#copyOf(java.util.EnumSet)
982     */
983    @SuppressWarnings("unchecked")
984    public void test_CopyOf_LEnumSet() {
985        EnumSet<EnumWithInnerClass> enumSet = EnumSet
986                .noneOf(EnumWithInnerClass.class);
987        enumSet.add(EnumWithInnerClass.a);
988        enumSet.add(EnumWithInnerClass.f);
989        EnumSet<EnumWithInnerClass> copyOfE = EnumSet.copyOf(enumSet);
990        assertEquals("Size of enumSet and copyOfE should be equal",
991                enumSet.size(), copyOfE.size());
992
993        assertTrue("EnumWithSubclass.a should be contained in copyOfE",
994                copyOfE.contains(EnumWithInnerClass.a));
995        assertTrue("EnumWithSubclass.f should be contained in copyOfE",
996                copyOfE.contains(EnumWithInnerClass.f));
997
998        Object[] enumValue = copyOfE.toArray();
999        assertSame("enumValue[0] should be identical with EnumWithSubclass.a",
1000                enumValue[0], EnumWithInnerClass.a);
1001        assertSame("enumValue[1] should be identical with EnumWithSubclass.f",
1002                enumValue[1], EnumWithInnerClass.f);
1003
1004        try {
1005            EnumSet.copyOf((EnumSet) null);
1006            fail("Should throw NullPointerException");
1007        } catch (NullPointerException npe) {
1008            // expected
1009        }
1010
1011        // test enum type with more than 64 elements
1012        EnumSet<HugeEnumWithInnerClass> hugeEnumSet = EnumSet
1013            .noneOf(HugeEnumWithInnerClass.class);
1014        hugeEnumSet.add(HugeEnumWithInnerClass.a);
1015        hugeEnumSet.add(HugeEnumWithInnerClass.f);
1016        EnumSet<HugeEnumWithInnerClass> copyOfHugeEnum = EnumSet.copyOf(hugeEnumSet);
1017        assertEquals(enumSet.size(), copyOfE.size());
1018
1019        assertTrue(copyOfHugeEnum.contains(HugeEnumWithInnerClass.a));
1020        assertTrue(copyOfHugeEnum.contains(HugeEnumWithInnerClass.f));
1021
1022        Object[] hugeEnumValue = copyOfHugeEnum.toArray();
1023        assertSame(hugeEnumValue[0], HugeEnumWithInnerClass.a);
1024        assertSame(hugeEnumValue[1], HugeEnumWithInnerClass.f);
1025    }
1026
1027    /**
1028     * java.util.EnumSet#removeAll(Collection)
1029     */
1030    @SuppressWarnings({ "unchecked", "CollectionIncompatibleType" })
1031    public void test_removeAll_LCollection() {
1032        Set<EnumFoo> set = EnumSet.noneOf(EnumFoo.class);
1033        try {
1034            set.removeAll(null);
1035            fail("Should throw NullPointerException");
1036        } catch (NullPointerException e) {
1037            // expected
1038        }
1039
1040        set = EnumSet.allOf(EnumFoo.class);
1041        assertEquals("Size of set should be 64:", 64, set.size());
1042
1043        try {
1044            set.removeAll(null);
1045            fail("Should throw NullPointerException");
1046        } catch (NullPointerException e) {
1047            // expected
1048        }
1049
1050        Collection<EnumFoo> collection = new ArrayList<EnumFoo>();
1051        collection.add(EnumFoo.a);
1052
1053        boolean result = set.removeAll(collection);
1054        assertTrue("Should return true", result);
1055        assertEquals("Size of set should be 63", 63, set.size());
1056
1057        collection = new ArrayList();
1058        result = set.removeAll(collection);
1059        assertFalse("Should return false", result);
1060
1061        Set<EmptyEnum> emptySet = EnumSet.noneOf(EmptyEnum.class);
1062        result = set.removeAll(emptySet);
1063        assertFalse("Should return false", result);
1064
1065        EnumSet<EnumFoo> emptyFooSet = EnumSet.noneOf(EnumFoo.class);
1066        result = set.removeAll(emptyFooSet);
1067        assertFalse("Should return false", result);
1068
1069        emptyFooSet.add(EnumFoo.a);
1070        result = set.removeAll(emptyFooSet);
1071        assertFalse("Should return false", result);
1072
1073        Set<EnumWithInnerClass> setWithSubclass = EnumSet
1074                .noneOf(EnumWithInnerClass.class);
1075        result = set.removeAll(setWithSubclass);
1076        assertFalse("Should return false", result);
1077
1078        setWithSubclass.add(EnumWithInnerClass.a);
1079        result = set.removeAll(setWithSubclass);
1080        assertFalse("Should return false", result);
1081
1082        Set<EnumFoo> anotherSet = EnumSet.noneOf(EnumFoo.class);
1083        anotherSet.add(EnumFoo.a);
1084
1085        set = EnumSet.allOf(EnumFoo.class);
1086        result = set.removeAll(anotherSet);
1087        assertTrue("Should return true", result);
1088        assertEquals("Size of set should be 63:", 63, set.size());
1089
1090        Set<EnumWithInnerClass> setWithInnerClass = EnumSet
1091                .noneOf(EnumWithInnerClass.class);
1092        setWithInnerClass.add(EnumWithInnerClass.a);
1093        setWithInnerClass.add(EnumWithInnerClass.b);
1094
1095        Set<EnumWithInnerClass> anotherSetWithInnerClass = EnumSet
1096                .noneOf(EnumWithInnerClass.class);
1097        anotherSetWithInnerClass.add(EnumWithInnerClass.c);
1098        anotherSetWithInnerClass.add(EnumWithInnerClass.d);
1099        result = anotherSetWithInnerClass.removeAll(setWithInnerClass);
1100        assertFalse("Should return false", result);
1101
1102        anotherSetWithInnerClass.add(EnumWithInnerClass.a);
1103        result = anotherSetWithInnerClass.removeAll(setWithInnerClass);
1104        assertTrue("Should return true", result);
1105        assertEquals("Size of anotherSetWithInnerClass should remain 2",
1106                2, anotherSetWithInnerClass.size());
1107
1108        anotherSetWithInnerClass.remove(EnumWithInnerClass.c);
1109        anotherSetWithInnerClass.remove(EnumWithInnerClass.d);
1110        result = anotherSetWithInnerClass.remove(setWithInnerClass);
1111        assertFalse("Should return false", result);
1112
1113        Set rawSet = EnumSet.allOf(EnumWithAllInnerClass.class);
1114        result = rawSet.removeAll(EnumSet.allOf(EnumFoo.class));
1115        assertFalse("Should return false", result);
1116
1117        setWithInnerClass = EnumSet.allOf(EnumWithInnerClass.class);
1118        anotherSetWithInnerClass = EnumSet.allOf(EnumWithInnerClass.class);
1119        setWithInnerClass.remove(EnumWithInnerClass.a);
1120        anotherSetWithInnerClass.remove(EnumWithInnerClass.f);
1121        result = setWithInnerClass.removeAll(anotherSetWithInnerClass);
1122        assertTrue("Should return true", result);
1123        assertEquals("Size of setWithInnerClass should be 1", 1, setWithInnerClass.size());
1124
1125        result = setWithInnerClass.contains(EnumWithInnerClass.f);
1126        assertTrue("Should return true", result);
1127
1128        // test enum type with more than 64 elements
1129        Set<HugeEnum> hugeSet = EnumSet.allOf(HugeEnum.class);
1130
1131        Collection<HugeEnum> hugeCollection = new ArrayList<HugeEnum>();
1132        hugeCollection.add(HugeEnum.a);
1133
1134        result = hugeSet.removeAll(hugeCollection);
1135        assertTrue(result);
1136        assertEquals(64, hugeSet.size());
1137
1138        collection = new ArrayList();
1139        result = hugeSet.removeAll(collection);
1140        assertFalse(result);
1141
1142        Set<HugeEnum> emptyHugeSet = EnumSet.noneOf(HugeEnum.class);
1143        result = hugeSet.removeAll(emptyHugeSet);
1144        assertFalse(result);
1145
1146        Set<HugeEnumWithInnerClass> hugeSetWithSubclass = EnumSet
1147                .noneOf(HugeEnumWithInnerClass.class);
1148        result = hugeSet.removeAll(hugeSetWithSubclass);
1149        assertFalse(result);
1150
1151        hugeSetWithSubclass.add(HugeEnumWithInnerClass.a);
1152        result = hugeSet.removeAll(hugeSetWithSubclass);
1153        assertFalse(result);
1154
1155        Set<HugeEnum> anotherHugeSet = EnumSet.noneOf(HugeEnum.class);
1156        anotherHugeSet.add(HugeEnum.a);
1157
1158        hugeSet = EnumSet.allOf(HugeEnum.class);
1159        result = hugeSet.removeAll(anotherHugeSet);
1160        assertTrue(result);
1161        assertEquals(63, set.size());
1162
1163        Set<HugeEnumWithInnerClass> hugeSetWithInnerClass = EnumSet
1164                .noneOf(HugeEnumWithInnerClass.class);
1165        hugeSetWithInnerClass.add(HugeEnumWithInnerClass.a);
1166        hugeSetWithInnerClass.add(HugeEnumWithInnerClass.b);
1167
1168        Set<HugeEnumWithInnerClass> anotherHugeSetWithInnerClass = EnumSet
1169                .noneOf(HugeEnumWithInnerClass.class);
1170        anotherHugeSetWithInnerClass.add(HugeEnumWithInnerClass.c);
1171        anotherHugeSetWithInnerClass.add(HugeEnumWithInnerClass.d);
1172        result = anotherHugeSetWithInnerClass.removeAll(setWithInnerClass);
1173        assertFalse("Should return false", result);
1174
1175        anotherHugeSetWithInnerClass.add(HugeEnumWithInnerClass.a);
1176        result = anotherHugeSetWithInnerClass.removeAll(hugeSetWithInnerClass);
1177        assertTrue(result);
1178        assertEquals(2, anotherHugeSetWithInnerClass.size());
1179
1180        anotherHugeSetWithInnerClass.remove(HugeEnumWithInnerClass.c);
1181        anotherHugeSetWithInnerClass.remove(HugeEnumWithInnerClass.d);
1182        result = anotherHugeSetWithInnerClass.remove(hugeSetWithInnerClass);
1183        assertFalse(result);
1184
1185        rawSet = EnumSet.allOf(HugeEnumWithInnerClass.class);
1186        result = rawSet.removeAll(EnumSet.allOf(HugeEnum.class));
1187        assertFalse(result);
1188
1189        hugeSetWithInnerClass = EnumSet.allOf(HugeEnumWithInnerClass.class);
1190        anotherHugeSetWithInnerClass = EnumSet.allOf(HugeEnumWithInnerClass.class);
1191        hugeSetWithInnerClass.remove(HugeEnumWithInnerClass.a);
1192        anotherHugeSetWithInnerClass.remove(HugeEnumWithInnerClass.f);
1193        result = hugeSetWithInnerClass.removeAll(anotherHugeSetWithInnerClass);
1194        assertTrue(result);
1195        assertEquals(1, hugeSetWithInnerClass.size());
1196
1197        result = hugeSetWithInnerClass.contains(HugeEnumWithInnerClass.f);
1198        assertTrue(result);
1199    }
1200
1201    /**
1202     * java.util.EnumSet#retainAll(Collection)
1203     */
1204    @SuppressWarnings({ "unchecked", "CollectionIncompatibleType" })
1205    public void test_retainAll_LCollection() {
1206        Set<EnumFoo> set = EnumSet.allOf(EnumFoo.class);
1207
1208        try {
1209            set.retainAll(null);
1210            fail("Should throw NullPointerException");
1211        } catch (NullPointerException e) {
1212            // expected
1213        }
1214
1215        set.clear();
1216        try {
1217            set.retainAll(null);
1218            fail("Should throw NullPointerException");
1219        } catch (NullPointerException e) {
1220            // expected
1221        }
1222
1223        Collection rawCollection = new ArrayList();
1224        boolean result = set.retainAll(rawCollection);
1225        assertFalse("Should return false", result);
1226
1227        rawCollection.add(EnumFoo.a);
1228        result = set.retainAll(rawCollection);
1229        assertFalse("Should return false", result);
1230
1231        rawCollection.add(EnumWithInnerClass.a);
1232        result = set.retainAll(rawCollection);
1233        assertFalse("Should return false", result);
1234        assertEquals("Size of set should be 0:", 0, set.size());
1235
1236        rawCollection.remove(EnumFoo.a);
1237        result = set.retainAll(rawCollection);
1238        assertFalse("Should return false", result);
1239
1240        Set<EnumFoo> anotherSet = EnumSet.allOf(EnumFoo.class);
1241        result = set.retainAll(anotherSet);
1242        assertFalse("Should return false", result);
1243        assertEquals("Size of set should be 0", 0, set.size());
1244
1245        Set<EnumWithInnerClass> setWithInnerClass = EnumSet
1246                .allOf(EnumWithInnerClass.class);
1247        result = set.retainAll(setWithInnerClass);
1248        assertFalse("Should return false", result);
1249        assertEquals("Size of set should be 0", 0, set.size());
1250
1251        setWithInnerClass = EnumSet.noneOf(EnumWithInnerClass.class);
1252        result = set.retainAll(setWithInnerClass);
1253        assertFalse("Should return false", result);
1254
1255        Set<EmptyEnum> emptySet = EnumSet.allOf(EmptyEnum.class);
1256        result = set.retainAll(emptySet);
1257        assertFalse("Should return false", result);
1258
1259        Set<EnumWithAllInnerClass> setWithAllInnerClass = EnumSet
1260                .allOf(EnumWithAllInnerClass.class);
1261        result = set.retainAll(setWithAllInnerClass);
1262        assertFalse("Should return false", result);
1263
1264        set.add(EnumFoo.a);
1265        result = set.retainAll(setWithInnerClass);
1266        assertTrue("Should return true", result);
1267        assertEquals("Size of set should be 0", 0, set.size());
1268
1269        setWithInnerClass = EnumSet.allOf(EnumWithInnerClass.class);
1270        setWithInnerClass.remove(EnumWithInnerClass.f);
1271        Set<EnumWithInnerClass> anotherSetWithInnerClass = EnumSet
1272                .noneOf(EnumWithInnerClass.class);
1273        anotherSetWithInnerClass.add(EnumWithInnerClass.e);
1274        anotherSetWithInnerClass.add(EnumWithInnerClass.f);
1275
1276        result = setWithInnerClass.retainAll(anotherSetWithInnerClass);
1277        assertTrue("Should return true", result);
1278        result = setWithInnerClass.contains(EnumWithInnerClass.e);
1279        assertTrue("Should contain EnumWithInnerClass.e", result);
1280        result = setWithInnerClass.contains(EnumWithInnerClass.b);
1281        assertFalse("Should not contain EnumWithInnerClass.b", result);
1282        assertEquals("Size of set should be 1:", 1, setWithInnerClass.size());
1283
1284        anotherSetWithInnerClass = EnumSet.allOf(EnumWithInnerClass.class);
1285        result = setWithInnerClass.retainAll(anotherSetWithInnerClass);
1286
1287        assertFalse("Return value should be false", result);
1288
1289        rawCollection = new ArrayList();
1290        rawCollection.add(EnumWithInnerClass.e);
1291        rawCollection.add(EnumWithInnerClass.f);
1292        result = setWithInnerClass.retainAll(rawCollection);
1293        assertFalse("Should return false", result);
1294
1295        set = EnumSet.allOf(EnumFoo.class);
1296        set.remove(EnumFoo.a);
1297        anotherSet = EnumSet.noneOf(EnumFoo.class);
1298        anotherSet.add(EnumFoo.a);
1299        result = set.retainAll(anotherSet);
1300        assertTrue("Should return true", result);
1301        assertEquals("size should be 0", 0, set.size());
1302
1303        // test enum type with more than 64 elements
1304        Set<HugeEnum> hugeSet = EnumSet.allOf(HugeEnum.class);
1305
1306        try {
1307            hugeSet.retainAll(null);
1308            fail("Should throw NullPointerException");
1309        } catch (NullPointerException e) {
1310            // expected
1311        }
1312
1313        hugeSet.clear();
1314        try {
1315            hugeSet.retainAll(null);
1316            fail("Should throw NullPointerException");
1317        } catch (NullPointerException e) {
1318            // expected
1319        }
1320
1321        rawCollection = new ArrayList();
1322        result = hugeSet.retainAll(rawCollection);
1323        assertFalse(result);
1324
1325        rawCollection.add(HugeEnum.a);
1326        result = hugeSet.retainAll(rawCollection);
1327        assertFalse(result);
1328
1329        rawCollection.add(HugeEnumWithInnerClass.a);
1330        result = hugeSet.retainAll(rawCollection);
1331        assertFalse(result);
1332        assertEquals(0, set.size());
1333
1334        rawCollection.remove(HugeEnum.a);
1335        result = set.retainAll(rawCollection);
1336        assertFalse(result);
1337
1338        Set<HugeEnum> anotherHugeSet = EnumSet.allOf(HugeEnum.class);
1339        result = hugeSet.retainAll(anotherHugeSet);
1340        assertFalse(result);
1341        assertEquals(0, hugeSet.size());
1342
1343        Set<HugeEnumWithInnerClass> hugeSetWithInnerClass = EnumSet
1344                .allOf(HugeEnumWithInnerClass.class);
1345        result = hugeSet.retainAll(hugeSetWithInnerClass);
1346        assertFalse(result);
1347        assertEquals(0, hugeSet.size());
1348
1349        hugeSetWithInnerClass = EnumSet.noneOf(HugeEnumWithInnerClass.class);
1350        result = hugeSet.retainAll(hugeSetWithInnerClass);
1351        assertFalse(result);
1352
1353        Set<HugeEnumWithInnerClass> hugeSetWithAllInnerClass = EnumSet
1354                .allOf(HugeEnumWithInnerClass.class);
1355        result = hugeSet.retainAll(hugeSetWithAllInnerClass);
1356        assertFalse(result);
1357
1358        hugeSet.add(HugeEnum.a);
1359        result = hugeSet.retainAll(hugeSetWithInnerClass);
1360        assertTrue(result);
1361        assertEquals(0, hugeSet.size());
1362
1363        hugeSetWithInnerClass = EnumSet.allOf(HugeEnumWithInnerClass.class);
1364        hugeSetWithInnerClass.remove(HugeEnumWithInnerClass.f);
1365        Set<HugeEnumWithInnerClass> anotherHugeSetWithInnerClass = EnumSet
1366                .noneOf(HugeEnumWithInnerClass.class);
1367        anotherHugeSetWithInnerClass.add(HugeEnumWithInnerClass.e);
1368        anotherHugeSetWithInnerClass.add(HugeEnumWithInnerClass.f);
1369
1370        result = hugeSetWithInnerClass.retainAll(anotherHugeSetWithInnerClass);
1371        assertTrue(result);
1372        result = hugeSetWithInnerClass.contains(HugeEnumWithInnerClass.e);
1373        assertTrue("Should contain HugeEnumWithInnerClass.e", result);
1374        result = hugeSetWithInnerClass.contains(HugeEnumWithInnerClass.b);
1375        assertFalse("Should not contain HugeEnumWithInnerClass.b", result);
1376        assertEquals("Size of hugeSet should be 1:", 1, hugeSetWithInnerClass.size());
1377
1378        anotherHugeSetWithInnerClass = EnumSet.allOf(HugeEnumWithInnerClass.class);
1379        result = hugeSetWithInnerClass.retainAll(anotherHugeSetWithInnerClass);
1380
1381        assertFalse("Return value should be false", result);
1382
1383        rawCollection = new ArrayList();
1384        rawCollection.add(HugeEnumWithInnerClass.e);
1385        rawCollection.add(HugeEnumWithInnerClass.f);
1386        result = hugeSetWithInnerClass.retainAll(rawCollection);
1387        assertFalse(result);
1388
1389        hugeSet = EnumSet.allOf(HugeEnum.class);
1390        hugeSet.remove(HugeEnum.a);
1391        anotherHugeSet = EnumSet.noneOf(HugeEnum.class);
1392        anotherHugeSet.add(HugeEnum.a);
1393        result = hugeSet.retainAll(anotherHugeSet);
1394        assertTrue(result);
1395        assertEquals(0, hugeSet.size());
1396    }
1397
1398    /**
1399     * java.util.EnumSet#iterator()
1400     */
1401    @SuppressWarnings("CollectionIncompatibleType")
1402    public void test_iterator() {
1403        Set<EnumFoo> set = EnumSet.noneOf(EnumFoo.class);
1404        set.add(EnumFoo.a);
1405        set.add(EnumFoo.b);
1406
1407        Iterator<EnumFoo> iterator = set.iterator();
1408        Iterator<EnumFoo> anotherIterator = set.iterator();
1409        assertNotSame("Should not be same", iterator, anotherIterator);
1410        try {
1411            iterator.remove();
1412            fail("Should throw IllegalStateException");
1413        } catch (IllegalStateException e) {
1414            // expectedd
1415        }
1416
1417        assertTrue("Should has next element:", iterator.hasNext());
1418        assertSame("Should be identical", EnumFoo.a, iterator.next());
1419        iterator.remove();
1420        assertTrue("Should has next element:", iterator.hasNext());
1421        assertSame("Should be identical", EnumFoo.b, iterator.next());
1422        assertFalse("Should not has next element:", iterator.hasNext());
1423        assertFalse("Should not has next element:", iterator.hasNext());
1424
1425        assertEquals("Size should be 1:", 1, set.size());
1426
1427        try {
1428            iterator.next();
1429            fail("Should throw NoSuchElementException");
1430        } catch (NoSuchElementException e) {
1431            // expected
1432        }
1433        set = EnumSet.noneOf(EnumFoo.class);
1434        set.add(EnumFoo.a);
1435        iterator = set.iterator();
1436        assertEquals("Should be equal", EnumFoo.a, iterator.next());
1437        iterator.remove();
1438        try {
1439            iterator.remove();
1440            fail("Should throw IllegalStateException");
1441        } catch(IllegalStateException e) {
1442            // expected
1443        }
1444
1445        Set<EmptyEnum> emptySet = EnumSet.allOf(EmptyEnum.class);
1446        Iterator<EmptyEnum> emptyIterator = emptySet.iterator();
1447        try {
1448            emptyIterator.next();
1449            fail("Should throw NoSuchElementException");
1450        } catch (NoSuchElementException e) {
1451            // expected
1452        }
1453
1454        Set<EnumWithInnerClass> setWithSubclass = EnumSet
1455                .allOf(EnumWithInnerClass.class);
1456        setWithSubclass.remove(EnumWithInnerClass.e);
1457        Iterator<EnumWithInnerClass> iteratorWithSubclass = setWithSubclass
1458                .iterator();
1459        assertSame("Should be same", EnumWithInnerClass.a, iteratorWithSubclass.next());
1460
1461        assertTrue("Should return true", iteratorWithSubclass.hasNext());
1462        assertSame("Should be same", EnumWithInnerClass.b, iteratorWithSubclass.next());
1463
1464        setWithSubclass.remove(EnumWithInnerClass.c);
1465        assertTrue("Should return true", iteratorWithSubclass.hasNext());
1466        assertSame("Should be same", EnumWithInnerClass.c, iteratorWithSubclass.next());
1467
1468        assertTrue("Should return true", iteratorWithSubclass.hasNext());
1469        assertSame("Should be same", EnumWithInnerClass.d, iteratorWithSubclass.next());
1470
1471        setWithSubclass.add(EnumWithInnerClass.e);
1472        assertTrue("Should return true", iteratorWithSubclass.hasNext());
1473        assertSame("Should be same", EnumWithInnerClass.f, iteratorWithSubclass.next());
1474
1475        set = EnumSet.noneOf(EnumFoo.class);
1476        iterator = set.iterator();
1477        try {
1478            iterator.next();
1479            fail("Should throw NoSuchElementException");
1480        } catch (NoSuchElementException e) {
1481            // expected
1482        }
1483
1484        set.add(EnumFoo.a);
1485        iterator = set.iterator();
1486        assertEquals("Should return EnumFoo.a", EnumFoo.a, iterator.next());
1487        assertEquals("Size of set should be 1", 1, set.size());
1488        iterator.remove();
1489        assertEquals("Size of set should be 0", 0, set.size());
1490        assertFalse("Should return false", set.contains(EnumFoo.a));
1491
1492        set.add(EnumFoo.a);
1493        set.add(EnumFoo.b);
1494        iterator = set.iterator();
1495        assertEquals("Should be equals", EnumFoo.a, iterator.next());
1496        iterator.remove();
1497        try {
1498            iterator.remove();
1499            fail("Should throw IllegalStateException");
1500        } catch(IllegalStateException e) {
1501            // expected
1502        }
1503
1504        assertTrue("Should have next element", iterator.hasNext());
1505        try {
1506            iterator.remove();
1507            fail("Should throw IllegalStateException");
1508        } catch (IllegalStateException e) {
1509            // expected
1510        }
1511        assertEquals("Size of set should be 1", 1, set.size());
1512        assertTrue("Should have next element", iterator.hasNext());
1513        assertEquals("Should return EnumFoo.b", EnumFoo.b, iterator.next());
1514        set.remove(EnumFoo.b);
1515        assertEquals("Size of set should be 0", 0, set.size());
1516        iterator.remove();
1517        assertFalse("Should return false", set.contains(EnumFoo.a));
1518
1519        // RI's bug, EnumFoo.b should not exist at the moment.
1520        if (!disableRIBugs) {
1521            assertFalse("Should return false", set.contains(EnumFoo.b));
1522        }
1523
1524        // test enum type with more than 64 elements
1525        Set<HugeEnum> hugeSet = EnumSet.noneOf(HugeEnum.class);
1526        hugeSet.add(HugeEnum.a);
1527        hugeSet.add(HugeEnum.b);
1528
1529        Iterator<HugeEnum> hIterator = hugeSet.iterator();
1530        Iterator<HugeEnum> anotherHugeIterator = hugeSet.iterator();
1531        assertNotSame(hIterator, anotherHugeIterator);
1532        try {
1533            hIterator.remove();
1534            fail("Should throw IllegalStateException");
1535        } catch (IllegalStateException e) {
1536            // expectedd
1537        }
1538
1539        assertTrue(hIterator.hasNext());
1540        assertSame(HugeEnum.a, hIterator.next());
1541        hIterator.remove();
1542        assertTrue(hIterator.hasNext());
1543        assertSame(HugeEnum.b, hIterator.next());
1544        assertFalse(hIterator.hasNext());
1545        assertFalse(hIterator.hasNext());
1546
1547        assertEquals(1, hugeSet.size());
1548
1549        try {
1550            hIterator.next();
1551            fail("Should throw NoSuchElementException");
1552        } catch (NoSuchElementException e) {
1553            // expected
1554        }
1555
1556        Set<HugeEnumWithInnerClass> hugeSetWithSubclass = EnumSet
1557                .allOf(HugeEnumWithInnerClass.class);
1558        hugeSetWithSubclass.remove(HugeEnumWithInnerClass.e);
1559        Iterator<HugeEnumWithInnerClass> hugeIteratorWithSubclass = hugeSetWithSubclass
1560                .iterator();
1561        assertSame(HugeEnumWithInnerClass.a, hugeIteratorWithSubclass.next());
1562
1563        assertTrue(hugeIteratorWithSubclass.hasNext());
1564        assertSame(HugeEnumWithInnerClass.b, hugeIteratorWithSubclass.next());
1565
1566        setWithSubclass.remove(HugeEnumWithInnerClass.c);
1567        assertTrue(hugeIteratorWithSubclass.hasNext());
1568        assertSame(HugeEnumWithInnerClass.c, hugeIteratorWithSubclass.next());
1569
1570        assertTrue(hugeIteratorWithSubclass.hasNext());
1571        assertSame(HugeEnumWithInnerClass.d, hugeIteratorWithSubclass.next());
1572
1573        hugeSetWithSubclass.add(HugeEnumWithInnerClass.e);
1574        assertTrue(hugeIteratorWithSubclass.hasNext());
1575        assertSame(HugeEnumWithInnerClass.f, hugeIteratorWithSubclass.next());
1576
1577        hugeSet = EnumSet.noneOf(HugeEnum.class);
1578        hIterator = hugeSet.iterator();
1579        try {
1580            hIterator.next();
1581            fail("Should throw NoSuchElementException");
1582        } catch (NoSuchElementException e) {
1583            // expected
1584        }
1585
1586        hugeSet.add(HugeEnum.a);
1587        hIterator = hugeSet.iterator();
1588        assertEquals(HugeEnum.a, hIterator.next());
1589        assertEquals(1, hugeSet.size());
1590        hIterator.remove();
1591        assertEquals(0, hugeSet.size());
1592        assertFalse(hugeSet.contains(HugeEnum.a));
1593
1594        hugeSet.add(HugeEnum.a);
1595        hugeSet.add(HugeEnum.b);
1596        hIterator = hugeSet.iterator();
1597        hIterator.next();
1598        hIterator.remove();
1599
1600        assertTrue(hIterator.hasNext());
1601        try {
1602            hIterator.remove();
1603            fail("Should throw IllegalStateException");
1604        } catch (IllegalStateException e) {
1605            // expected
1606        }
1607        assertEquals(1, hugeSet.size());
1608        assertTrue(hIterator.hasNext());
1609        assertEquals(HugeEnum.b, hIterator.next());
1610        hugeSet.remove(HugeEnum.b);
1611        assertEquals(0, hugeSet.size());
1612        hIterator.remove();
1613        assertFalse(hugeSet.contains(HugeEnum.a));
1614        // RI's bug, EnumFoo.b should not exist at the moment.
1615        if(!disableRIBugs) {
1616            assertFalse("Should return false", set.contains(EnumFoo.b));
1617        }
1618    }
1619
1620    /**
1621     * java.util.EnumSet#of(E)
1622     */
1623    public void test_Of_E() {
1624        EnumSet<EnumWithInnerClass> enumSet = EnumSet.of(EnumWithInnerClass.a);
1625        assertEquals("enumSet should have length 1:", 1, enumSet.size());
1626
1627        assertTrue("enumSet should contain EnumWithSubclass.a:",
1628                enumSet.contains(EnumWithInnerClass.a));
1629
1630        try {
1631            EnumSet.of((EnumWithInnerClass) null);
1632            fail("Should throw NullPointerException");
1633        } catch (NullPointerException npe) {
1634            // expected
1635        }
1636
1637        // test enum type with more than 64 elements
1638        EnumSet<HugeEnumWithInnerClass> hugeEnumSet = EnumSet.of(HugeEnumWithInnerClass.a);
1639        assertEquals(1, hugeEnumSet.size());
1640
1641        assertTrue(hugeEnumSet.contains(HugeEnumWithInnerClass.a));
1642    }
1643
1644    /**
1645     * java.util.EnumSet#of(E, E)
1646     */
1647    public void test_Of_EE() {
1648        EnumSet<EnumWithInnerClass> enumSet = EnumSet.of(EnumWithInnerClass.a,
1649                EnumWithInnerClass.b);
1650        assertEquals("enumSet should have length 2:", 2, enumSet.size());
1651
1652        assertTrue("enumSet should contain EnumWithSubclass.a:",
1653                enumSet.contains(EnumWithInnerClass.a));
1654        assertTrue("enumSet should contain EnumWithSubclass.b:",
1655                enumSet.contains(EnumWithInnerClass.b));
1656
1657        try {
1658            EnumSet.of((EnumWithInnerClass) null, EnumWithInnerClass.a);
1659            fail("Should throw NullPointerException");
1660        } catch (NullPointerException npe) {
1661            // expected
1662        }
1663
1664        try {
1665            EnumSet.of( EnumWithInnerClass.a, (EnumWithInnerClass) null);
1666            fail("Should throw NullPointerException");
1667        } catch (NullPointerException npe) {
1668            // expected
1669        }
1670
1671        try {
1672            EnumSet.of( (EnumWithInnerClass) null, (EnumWithInnerClass) null);
1673            fail("Should throw NullPointerException");
1674        } catch (NullPointerException npe) {
1675            // expected
1676        }
1677
1678        enumSet = EnumSet.of(EnumWithInnerClass.a, EnumWithInnerClass.a);
1679        assertEquals("Size of enumSet should be 1",
1680                1, enumSet.size());
1681
1682        // test enum type with more than 64 elements
1683        EnumSet<HugeEnumWithInnerClass> hugeEnumSet = EnumSet.of(HugeEnumWithInnerClass.a,
1684                HugeEnumWithInnerClass.b);
1685        assertEquals(2, hugeEnumSet.size());
1686
1687        assertTrue(hugeEnumSet.contains(HugeEnumWithInnerClass.a));
1688        assertTrue(hugeEnumSet.contains(HugeEnumWithInnerClass.b));
1689
1690        try {
1691            EnumSet.of((HugeEnumWithInnerClass) null, HugeEnumWithInnerClass.a);
1692            fail("Should throw NullPointerException");
1693        } catch (NullPointerException npe) {
1694            // expected
1695        }
1696
1697        try {
1698            EnumSet.of( HugeEnumWithInnerClass.a, (HugeEnumWithInnerClass) null);
1699            fail("Should throw NullPointerException");
1700        } catch (NullPointerException npe) {
1701            // expected
1702        }
1703
1704        try {
1705            EnumSet.of( (HugeEnumWithInnerClass) null, (HugeEnumWithInnerClass) null);
1706            fail("Should throw NullPointerException");
1707        } catch (NullPointerException npe) {
1708            // expected
1709        }
1710
1711        hugeEnumSet = EnumSet.of(HugeEnumWithInnerClass.a, HugeEnumWithInnerClass.a);
1712        assertEquals(1, hugeEnumSet.size());
1713    }
1714
1715    /**
1716     * java.util.EnumSet#of(E, E, E)
1717     */
1718    public void test_Of_EEE() {
1719        EnumSet<EnumWithInnerClass> enumSet = EnumSet.of(EnumWithInnerClass.a,
1720                EnumWithInnerClass.b, EnumWithInnerClass.c);
1721        assertEquals("Size of enumSet should be 3:", 3, enumSet.size());
1722
1723        assertTrue(
1724                "enumSet should contain EnumWithSubclass.a:", enumSet.contains(EnumWithInnerClass.a));
1725        assertTrue("Should return true", enumSet.contains(EnumWithInnerClass.c));
1726
1727        try {
1728            EnumSet.of((EnumWithInnerClass) null, null, null);
1729            fail("Should throw NullPointerException");
1730        } catch (NullPointerException npe) {
1731            // expected
1732        }
1733
1734        enumSet = EnumSet.of(EnumWithInnerClass.a, EnumWithInnerClass.b,
1735                EnumWithInnerClass.b);
1736        assertEquals("enumSet should contain 2 elements:", 2, enumSet.size());
1737
1738        // test enum type with more than 64 elements
1739        EnumSet<HugeEnumWithInnerClass> hugeEnumSet = EnumSet.of(HugeEnumWithInnerClass.a,
1740                HugeEnumWithInnerClass.b, HugeEnumWithInnerClass.c);
1741        assertEquals(3, hugeEnumSet.size());
1742
1743        assertTrue(hugeEnumSet.contains(HugeEnumWithInnerClass.a));
1744        assertTrue(hugeEnumSet.contains(HugeEnumWithInnerClass.c));
1745
1746        try {
1747            EnumSet.of((HugeEnumWithInnerClass) null, null, null);
1748            fail("Should throw NullPointerException");
1749        } catch (NullPointerException npe) {
1750            // expected
1751        }
1752
1753        hugeEnumSet = EnumSet.of(HugeEnumWithInnerClass.a, HugeEnumWithInnerClass.b,
1754                HugeEnumWithInnerClass.b);
1755        assertEquals(2, hugeEnumSet.size());
1756    }
1757
1758    /**
1759     * java.util.EnumSet#of(E, E, E, E)
1760     */
1761    public void test_Of_EEEE() {
1762        EnumSet<EnumWithInnerClass> enumSet = EnumSet.of(EnumWithInnerClass.a,
1763                EnumWithInnerClass.b, EnumWithInnerClass.c,
1764                EnumWithInnerClass.d);
1765        assertEquals("Size of enumSet should be 4", 4, enumSet.size());
1766
1767        assertTrue(
1768                "enumSet should contain EnumWithSubclass.a:", enumSet.contains(EnumWithInnerClass.a));
1769        assertTrue("enumSet should contain EnumWithSubclass.d:", enumSet
1770                .contains(EnumWithInnerClass.d));
1771
1772        try {
1773            EnumSet.of((EnumWithInnerClass) null, null, null, null);
1774            fail("Should throw NullPointerException");
1775        } catch (NullPointerException npe) {
1776            // expected
1777        }
1778
1779        // test enum type with more than 64 elements
1780        EnumSet<HugeEnumWithInnerClass> hugeEnumSet = EnumSet.of(HugeEnumWithInnerClass.a,
1781                HugeEnumWithInnerClass.b, HugeEnumWithInnerClass.c,
1782                HugeEnumWithInnerClass.d);
1783        assertEquals(4, hugeEnumSet.size());
1784
1785        assertTrue(hugeEnumSet.contains(HugeEnumWithInnerClass.a));
1786        assertTrue(hugeEnumSet.contains(HugeEnumWithInnerClass.d));
1787
1788        try {
1789            EnumSet.of((HugeEnumWithInnerClass) null, null, null, null);
1790            fail("Should throw NullPointerException");
1791        } catch (NullPointerException npe) {
1792            // expected
1793        }
1794    }
1795
1796    /**
1797     * java.util.EnumSet#of(E, E, E, E, E)
1798     */
1799    public void test_Of_EEEEE() {
1800        EnumSet<EnumWithInnerClass> enumSet = EnumSet.of(EnumWithInnerClass.a,
1801                EnumWithInnerClass.b, EnumWithInnerClass.c,
1802                EnumWithInnerClass.d, EnumWithInnerClass.e);
1803        assertEquals("Size of enumSet should be 5:", 5, enumSet.size());
1804
1805        assertTrue("Should return true", enumSet.contains(EnumWithInnerClass.a));
1806        assertTrue("Should return true", enumSet.contains(EnumWithInnerClass.e));
1807
1808        try {
1809            EnumSet.of((EnumWithInnerClass) null, null, null, null, null);
1810            fail("Should throw NullPointerException");
1811        } catch (NullPointerException npe) {
1812            // expected
1813        }
1814
1815        // test enum with more than 64 elements
1816        EnumSet<HugeEnumWithInnerClass> hugeEnumSet = EnumSet.of(HugeEnumWithInnerClass.a,
1817                HugeEnumWithInnerClass.b, HugeEnumWithInnerClass.c,
1818                HugeEnumWithInnerClass.d, HugeEnumWithInnerClass.e);
1819        assertEquals(5, hugeEnumSet.size());
1820
1821        assertTrue(hugeEnumSet.contains(HugeEnumWithInnerClass.a));
1822        assertTrue(hugeEnumSet.contains(HugeEnumWithInnerClass.e));
1823
1824        try {
1825            EnumSet.of((HugeEnumWithInnerClass) null, null, null, null, null);
1826            fail("Should throw NullPointerException");
1827        } catch (NullPointerException npe) {
1828            // expected
1829        }
1830    }
1831
1832    /**
1833     * java.util.EnumSet#of(E, E...)
1834     */
1835    public void test_Of_EEArray() {
1836        EnumWithInnerClass[] enumArray = new EnumWithInnerClass[] {
1837                EnumWithInnerClass.b, EnumWithInnerClass.c };
1838        EnumSet<EnumWithInnerClass> enumSet = EnumSet.of(EnumWithInnerClass.a,
1839                enumArray);
1840        assertEquals("Should be equal", 3, enumSet.size());
1841
1842        assertTrue("Should return true", enumSet.contains(EnumWithInnerClass.a));
1843        assertTrue("Should return true", enumSet.contains(EnumWithInnerClass.c));
1844
1845        try {
1846            EnumSet.of(EnumWithInnerClass.a, (EnumWithInnerClass[])null);
1847            fail("Should throw NullPointerException");
1848        } catch (NullPointerException npe) {
1849            // expected
1850        }
1851
1852        EnumFoo[] foos = {EnumFoo.a, EnumFoo.c, EnumFoo.d};
1853        EnumSet<EnumFoo> set = EnumSet.of(EnumFoo.c, foos);
1854        assertEquals("size of set should be 1", 3, set.size());
1855        assertTrue("Should contain EnumFoo.a", set.contains(EnumFoo.a));
1856        assertTrue("Should contain EnumFoo.c", set.contains(EnumFoo.c));
1857        assertTrue("Should contain EnumFoo.d", set.contains(EnumFoo.d));
1858
1859        // test enum type with more than 64 elements
1860        HugeEnumWithInnerClass[] hugeEnumArray = new HugeEnumWithInnerClass[] {
1861                HugeEnumWithInnerClass.b, HugeEnumWithInnerClass.c };
1862        EnumSet<HugeEnumWithInnerClass> hugeEnumSet = EnumSet.of(HugeEnumWithInnerClass.a,
1863                hugeEnumArray);
1864        assertEquals(3, hugeEnumSet.size());
1865
1866        assertTrue(hugeEnumSet.contains(HugeEnumWithInnerClass.a));
1867        assertTrue(hugeEnumSet.contains(HugeEnumWithInnerClass.c));
1868
1869        try {
1870            EnumSet.of(HugeEnumWithInnerClass.a, (HugeEnumWithInnerClass[])null);
1871            fail("Should throw NullPointerException");
1872        } catch (NullPointerException npe) {
1873            // expected
1874        }
1875
1876        HugeEnumWithInnerClass[] huges = {HugeEnumWithInnerClass.a, HugeEnumWithInnerClass.c, HugeEnumWithInnerClass.d};
1877        EnumSet<HugeEnumWithInnerClass> hugeSet = EnumSet.of(HugeEnumWithInnerClass.c, huges);
1878        assertEquals(3, hugeSet.size());
1879        assertTrue(hugeSet.contains(HugeEnumWithInnerClass.a));
1880        assertTrue(hugeSet.contains(HugeEnumWithInnerClass.c));
1881        assertTrue(hugeSet.contains(HugeEnumWithInnerClass.d));
1882    }
1883
1884    /**
1885     * java.util.EnumSet#range(E, E)
1886     */
1887    public void test_Range_EE() {
1888        try {
1889            EnumSet.range(EnumWithInnerClass.c, null);
1890            fail("Should throw NullPointerException");
1891        } catch (NullPointerException e) {
1892            // expected
1893        }
1894
1895        try {
1896            EnumSet.range(null, EnumWithInnerClass.c);
1897            fail("Should throw NullPointerException");
1898        } catch (NullPointerException e) {
1899            // expected
1900        }
1901
1902        try {
1903            EnumSet.range(null, (EnumWithInnerClass) null);
1904            fail("Should throw NullPointerException");
1905        } catch (NullPointerException e) {
1906            // expected
1907        }
1908
1909        try {
1910            EnumSet.range(EnumWithInnerClass.b, EnumWithInnerClass.a);
1911            fail("Should throw IllegalArgumentException");
1912        } catch (IllegalArgumentException e) {
1913            // expected
1914        }
1915
1916        EnumSet<EnumWithInnerClass> enumSet = EnumSet.range(
1917                EnumWithInnerClass.a, EnumWithInnerClass.a);
1918        assertEquals("Size of enumSet should be 1", 1, enumSet.size());
1919
1920        enumSet = EnumSet.range(
1921                EnumWithInnerClass.a, EnumWithInnerClass.c);
1922        assertEquals("Size of enumSet should be 3", 3, enumSet.size());
1923
1924        // test enum with more than 64 elements
1925        try {
1926            EnumSet.range(HugeEnumWithInnerClass.c, null);
1927            fail("Should throw NullPointerException");
1928        } catch (NullPointerException e) {
1929            // expected
1930        }
1931
1932        try {
1933            EnumSet.range(null, HugeEnumWithInnerClass.c);
1934            fail("Should throw NullPointerException");
1935        } catch (NullPointerException e) {
1936            // expected
1937        }
1938
1939        try {
1940            EnumSet.range(null, (HugeEnumWithInnerClass) null);
1941            fail("Should throw NullPointerException");
1942        } catch (NullPointerException e) {
1943            // expected
1944        }
1945
1946        try {
1947            EnumSet.range(HugeEnumWithInnerClass.b, HugeEnumWithInnerClass.a);
1948            fail("Should throw IllegalArgumentException");
1949        } catch (IllegalArgumentException e) {
1950            // expected
1951        }
1952
1953        EnumSet<HugeEnumWithInnerClass> hugeEnumSet = EnumSet.range(
1954                HugeEnumWithInnerClass.a, HugeEnumWithInnerClass.a);
1955        assertEquals(1, hugeEnumSet.size());
1956
1957        hugeEnumSet = EnumSet.range(
1958                HugeEnumWithInnerClass.c, HugeEnumWithInnerClass.aa);
1959        assertEquals(51, hugeEnumSet.size());
1960
1961        hugeEnumSet = EnumSet.range(
1962                HugeEnumWithInnerClass.a, HugeEnumWithInnerClass.mm);
1963        assertEquals(65, hugeEnumSet.size());
1964
1965        hugeEnumSet = EnumSet.range(
1966                HugeEnumWithInnerClass.b, HugeEnumWithInnerClass.mm);
1967        assertEquals(64, hugeEnumSet.size());
1968    }
1969
1970    /**
1971     * java.util.EnumSet#clone()
1972     */
1973    public void test_Clone() {
1974        EnumSet<EnumFoo> enumSet = EnumSet.allOf(EnumFoo.class);
1975        EnumSet<EnumFoo> clonedEnumSet = enumSet.clone();
1976        assertEquals(enumSet, clonedEnumSet);
1977        assertNotSame(enumSet, clonedEnumSet);
1978        assertTrue(clonedEnumSet.contains(EnumFoo.a));
1979        assertTrue(clonedEnumSet.contains(EnumFoo.b));
1980        assertEquals(64, clonedEnumSet.size());
1981
1982        // test enum type with more than 64 elements
1983        EnumSet<HugeEnum> hugeEnumSet = EnumSet.allOf(HugeEnum.class);
1984        EnumSet<HugeEnum> hugeClonedEnumSet = hugeEnumSet.clone();
1985        assertEquals(hugeEnumSet, hugeClonedEnumSet);
1986        assertNotSame(hugeEnumSet, hugeClonedEnumSet);
1987        assertTrue(hugeClonedEnumSet.contains(HugeEnum.a));
1988        assertTrue(hugeClonedEnumSet.contains(HugeEnum.b));
1989        assertEquals(65, hugeClonedEnumSet.size());
1990
1991        hugeClonedEnumSet.remove(HugeEnum.a);
1992        assertEquals(64, hugeClonedEnumSet.size());
1993        assertFalse(hugeClonedEnumSet.contains(HugeEnum.a));
1994        assertEquals(65, hugeEnumSet.size());
1995        assertTrue(hugeEnumSet.contains(HugeEnum.a));
1996    }
1997
1998    /**
1999     * java.util.EnumSet#Serialization()
2000     */
2001    public void test_serialization() throws Exception {
2002        EnumSet<EnumFoo> set = EnumSet.allOf(EnumFoo.class);
2003        SerializationTest.verifySelf(set);
2004    }
2005
2006    /**
2007     * serialization/deserialization compatibility with RI.
2008     */
2009    @SuppressWarnings( { "unchecked", "boxing" })
2010    public void testSerializationCompatibility() throws Exception {
2011        EnumSet<EnumFoo> set = EnumSet.allOf(EnumFoo.class);
2012        SerializationTest.verifyGolden(this, set);
2013    }
2014}
2015