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 tests.api.java.util;
18
19import java.util.Arrays;
20import java.util.Collection;
21import java.util.Iterator;
22import java.util.LinkedHashSet;
23import java.util.Set;
24import java.util.Vector;
25
26/**
27 * java.util.LinkedHashSet
28 */
29
30public class LinkedHashSetTest extends junit.framework.TestCase {
31
32    LinkedHashSet hs;
33
34    Object[] objArray;
35
36    /**
37     * java.util.LinkedHashSet#LinkedHashSet()
38     */
39    public void test_Constructor() {
40        // Test for method java.util.LinkedHashSet()
41        LinkedHashSet hs2 = new LinkedHashSet();
42        assertEquals("Created incorrect LinkedHashSet", 0, hs2.size());
43    }
44
45    /**
46     * java.util.LinkedHashSet#LinkedHashSet(int)
47     */
48    public void test_ConstructorI() {
49        // Test for method java.util.LinkedHashSet(int)
50        LinkedHashSet hs2 = new LinkedHashSet(5);
51        assertEquals("Created incorrect LinkedHashSet", 0, hs2.size());
52        try {
53            new LinkedHashSet(-1);
54            fail("IllegalArgumentException expected");
55        } catch (IllegalArgumentException e) {
56            //expected
57        }
58    }
59
60    /**
61     * java.util.LinkedHashSet#LinkedHashSet(int, float)
62     */
63    public void test_ConstructorIF() {
64        // Test for method java.util.LinkedHashSet(int, float)
65        LinkedHashSet hs2 = new LinkedHashSet(5, (float) 0.5);
66        assertEquals("Created incorrect LinkedHashSet", 0, hs2.size());
67
68        try {
69            new LinkedHashSet(-1, 0.5f);
70            fail("IllegalArgumentException expected");
71        } catch (IllegalArgumentException e) {
72            //expected
73        }
74
75        try {
76            new LinkedHashSet(1, -0.5f);
77            fail("IllegalArgumentException expected");
78        } catch (IllegalArgumentException e) {
79            //expected
80        }
81
82        try {
83            new LinkedHashSet(1, 0f);
84            fail("IllegalArgumentException expected");
85        } catch (IllegalArgumentException e) {
86            //expected
87        }
88    }
89
90    /**
91     * java.util.LinkedHashSet#LinkedHashSet(java.util.Collection)
92     */
93    public void test_ConstructorLjava_util_Collection() {
94        // Test for method java.util.LinkedHashSet(java.util.Collection)
95        LinkedHashSet hs2 = new LinkedHashSet(Arrays.asList(objArray));
96        for (int counter = 0; counter < objArray.length; counter++)
97            assertTrue("LinkedHashSet does not contain correct elements", hs
98                    .contains(objArray[counter]));
99        assertTrue("LinkedHashSet created from collection incorrect size", hs2
100                .size() == objArray.length);
101
102        try {
103            new LinkedHashSet(null);
104            fail("NullPointerException expected");
105        } catch (NullPointerException e) {
106            //expected
107        }
108    }
109
110    /**
111     * java.util.LinkedHashSet#add(java.lang.Object)
112     */
113    public void test_addLjava_lang_Object() {
114        // Test for method boolean java.util.LinkedHashSet.add(java.lang.Object)
115        int size = hs.size();
116        hs.add(new Integer(8));
117        assertTrue("Added element already contained by set", hs.size() == size);
118        hs.add(new Integer(-9));
119        assertTrue("Failed to increment set size after add",
120                hs.size() == size + 1);
121        assertTrue("Failed to add element to set", hs.contains(new Integer(-9)));
122    }
123
124    /**
125     * java.util.LinkedHashSet#clear()
126     */
127    public void test_clear() {
128        // Test for method void java.util.LinkedHashSet.clear()
129        Set orgSet = (Set) hs.clone();
130        hs.clear();
131        Iterator i = orgSet.iterator();
132        assertEquals("Returned non-zero size after clear", 0, hs.size());
133        while (i.hasNext())
134            assertTrue("Failed to clear set", !hs.contains(i.next()));
135    }
136
137    /**
138     * java.util.LinkedHashSet#clone()
139     */
140    public void test_clone() {
141        // Test for method java.lang.Object java.util.LinkedHashSet.clone()
142        LinkedHashSet hs2 = (LinkedHashSet) hs.clone();
143        assertTrue("clone returned an equivalent LinkedHashSet", hs != hs2);
144        assertTrue("clone did not return an equal LinkedHashSet", hs
145                .equals(hs2));
146    }
147
148    /**
149     * java.util.LinkedHashSet#contains(java.lang.Object)
150     */
151    public void test_containsLjava_lang_Object() {
152        // Test for method boolean
153        // java.util.LinkedHashSet.contains(java.lang.Object)
154        assertTrue("Returned false for valid object", hs.contains(objArray[90]));
155        assertTrue("Returned true for invalid Object", !hs
156                .contains(new Object()));
157
158        LinkedHashSet s = new LinkedHashSet();
159        s.add(null);
160        assertTrue("Cannot handle null", s.contains(null));
161    }
162
163    /**
164     * java.util.LinkedHashSet#isEmpty()
165     */
166    public void test_isEmpty() {
167        // Test for method boolean java.util.LinkedHashSet.isEmpty()
168        assertTrue("Empty set returned false", new LinkedHashSet().isEmpty());
169        assertTrue("Non-empty set returned true", !hs.isEmpty());
170    }
171
172    /**
173     * java.util.LinkedHashSet#iterator()
174     */
175    public void test_iterator() {
176        // Test for method java.util.Iterator java.util.LinkedHashSet.iterator()
177        Iterator i = hs.iterator();
178        int x = 0;
179        int j;
180        for (j = 0; i.hasNext(); j++) {
181            Object oo = i.next();
182            if (oo != null) {
183                Integer ii = (Integer) oo;
184                assertTrue("Incorrect element found", ii.intValue() == j);
185            } else {
186                assertTrue("Cannot find null", hs.contains(oo));
187            }
188            ++x;
189        }
190        assertTrue("Returned iteration of incorrect size", hs.size() == x);
191
192        LinkedHashSet s = new LinkedHashSet();
193        s.add(null);
194        assertNull("Cannot handle null", s.iterator().next());
195    }
196
197    /**
198     * java.util.LinkedHashSet#remove(java.lang.Object)
199     */
200    public void test_removeLjava_lang_Object() {
201        // Test for method boolean
202        // java.util.LinkedHashSet.remove(java.lang.Object)
203        int size = hs.size();
204        hs.remove(new Integer(98));
205        assertTrue("Failed to remove element", !hs.contains(new Integer(98)));
206        assertTrue("Failed to decrement set size", hs.size() == size - 1);
207
208        LinkedHashSet s = new LinkedHashSet();
209        s.add(null);
210        assertTrue("Cannot handle null", s.remove(null));
211    }
212
213    /**
214     * java.util.LinkedHashSet#size()
215     */
216    public void test_size() {
217        // Test for method int java.util.LinkedHashSet.size()
218        assertTrue("Returned incorrect size", hs.size() == (objArray.length + 1));
219        hs.clear();
220        assertEquals("Cleared set returned non-zero size", 0, hs.size());
221    }
222
223    class Mock_LinkedHashSet extends LinkedHashSet {
224        @Override
225        public boolean retainAll(Collection c) {
226            throw new UnsupportedOperationException();
227        }
228    }
229
230    public void test_retainAllLjava_util_Collection() {
231        LinkedHashSet<Integer> lhs = new LinkedHashSet<Integer>();
232        Vector v = new Vector<Float>();
233        v.add(new Float(3.14));
234        lhs.add(new Integer(1));
235        assertEquals(1, lhs.size());
236        lhs.retainAll(v);
237        assertEquals(0, lhs.size());
238        v = new Vector<Integer>();
239        v.add(new Integer(1));
240        v.add(new Integer(2));
241        v.add(new Integer(3));
242        v.add(new Integer(4));
243        v.add(new Integer(5));
244        v.add(new Integer(6));
245        lhs.add(new Integer(1));
246        lhs.add(new Integer(6));
247        lhs.add(new Integer(7));
248        lhs.add(new Integer(8));
249        lhs.add(new Integer(9));
250        lhs.add(new Integer(10));
251        lhs.add(new Integer(11));
252        lhs.add(new Integer(12));
253        lhs.add(new Integer(13));
254        assertEquals(9, lhs.size());
255        lhs.retainAll(v);
256        assertEquals(2, lhs.size());
257
258        try {
259            lhs.retainAll(null);
260            fail("NullPointerException expected");
261        } catch (NullPointerException e) {
262            //expected
263        }
264
265        lhs = new Mock_LinkedHashSet();
266
267        try {
268            lhs.retainAll(v);
269            fail("UnsupportedOperationException expected");
270        } catch (UnsupportedOperationException e) {
271            //expected
272        }
273    }
274
275    public void test_toArray() {
276        LinkedHashSet<Integer> lhs = new LinkedHashSet<Integer>();
277        lhs.add(new Integer(1));
278        lhs.add(new Integer(6));
279        lhs.add(new Integer(7));
280        lhs.add(new Integer(8));
281        lhs.add(new Integer(9));
282        lhs.add(new Integer(10));
283        lhs.add(new Integer(11));
284        lhs.add(new Integer(12));
285        lhs.add(new Integer(13));
286
287        Object[] o = lhs.toArray();
288        for (int i = 0; i < o.length; i++) {
289            assertTrue(lhs.contains(o[i]));
290        }
291        assertEquals(lhs.size(), o.length);
292    }
293
294    public void test_toArray$Ljava_lang_Object() {
295        LinkedHashSet<Integer> lhs = new LinkedHashSet<Integer>();
296        lhs.add(new Integer(1));
297        lhs.add(new Integer(6));
298        lhs.add(new Integer(7));
299        lhs.add(new Integer(8));
300        lhs.add(new Integer(9));
301        lhs.add(new Integer(10));
302        lhs.add(new Integer(11));
303        lhs.add(new Integer(12));
304        lhs.add(new Integer(13));
305
306        Object[] o1 = new Object[lhs.size()];
307        Object[] o2 = new Double[lhs.size()];
308        lhs.toArray(o1);
309        for (int i = 0; i < o1.length; i++) {
310            assertTrue(lhs.contains(o1[i]));
311        }
312
313        try {
314            lhs.toArray(null);
315            fail("NullPointerException expected");
316        } catch (NullPointerException e) {
317            //expected
318        }
319
320        try {
321            lhs.toArray(o2);
322            fail("ArrayStoreException expected");
323        } catch (ArrayStoreException e) {
324            //expected
325        }
326    }
327
328    /**
329     * Sets up the fixture, for example, open a network connection. This method
330     * is called before a test is executed.
331     */
332    protected void setUp() {
333        objArray = new Object[1000];
334        for (int i = 0; i < objArray.length; i++)
335            objArray[i] = new Integer(i);
336
337        hs = new LinkedHashSet();
338        for (int i = 0; i < objArray.length; i++)
339            hs.add(objArray[i]);
340        hs.add(null);
341    }
342
343    /**
344     * Tears down the fixture, for example, close a network connection. This
345     * method is called after a test is executed.
346     */
347    protected void tearDown() {
348        objArray = null;
349        hs = null;
350    }
351}
352