IdentityHashMapTest.java revision 2ad60cfc28e14ee8f0bb038720836a4696c478ad 
1/*
2 *  Licensed to the Apache Software Foundation (ASF) under one or more
3 *  contributor license agreements.  See the NOTICE file distributed with
4 *  this work for additional information regarding copyright ownership.
5 *  The ASF licenses this file to You under the Apache License, Version 2.0
6 *  (the "License"); you may not use this file except in compliance with
7 *  the License.  You may obtain a copy of the License at
8 *
9 *     http://www.apache.org/licenses/LICENSE-2.0
10 *
11 *  Unless required by applicable law or agreed to in writing, software
12 *  distributed under the License is distributed on an "AS IS" BASIS,
13 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 *  See the License for the specific language governing permissions and
15 *  limitations under the License.
16 */
17
18package org.apache.harmony.luni.tests.java.util;
19
20import java.io.Serializable;
21import java.util.Collection;
22import java.util.HashSet;
23import java.util.IdentityHashMap;
24import java.util.Iterator;
25import java.util.Map;
26import java.util.Set;
27import java.util.TreeSet;
28
29import org.apache.harmony.testframework.serialization.SerializationTest;
30import org.apache.harmony.testframework.serialization.SerializationTest.SerializableAssert;
31
32public class IdentityHashMapTest extends junit.framework.TestCase {
33
34    /**
35     * @tests java.util.IdentityHashMap#containsKey(java.lang.Object)
36     * @tests java.util.IdentityHashMap#containsValue(java.lang.Object)
37     * @tests java.util.IdentityHashMap#put(java.lang.Object, java.lang.Object)
38     * @tests java.util.IdentityHashMap#get(java.lang.Object)
39     */
40    public void test_null_Keys_and_Values() {
41        // tests with null keys and values
42        IdentityHashMap map = new IdentityHashMap();
43        Object result;
44
45        // null key and null value
46        result = map.put(null, null);
47        assertTrue("testA can not find null key", map.containsKey(null));
48        assertTrue("testA can not find null value", map.containsValue(null));
49        assertNull("testA can not get null value for null key",
50                map.get(null));
51        assertNull("testA put returned wrong value", result);
52
53        // null value
54        String value = "a value";
55        result = map.put(null, value);
56        assertTrue("testB can not find null key", map.containsKey(null));
57        assertTrue("testB can not find a value with null key", map
58                .containsValue(value));
59        assertTrue("testB can not get value for null key",
60                map.get(null) == value);
61        assertNull("testB put returned wrong value", result);
62
63        // a null key
64        String key = "a key";
65        result = map.put(key, null);
66        assertTrue("testC can not find a key with null value", map
67                .containsKey(key));
68        assertTrue("testC can not find null value", map.containsValue(null));
69        assertNull("testC can not get null value for key", map.get(key));
70        assertNull("testC put returned wrong value", result);
71
72        // another null key
73        String anothervalue = "another value";
74        result = map.put(null, anothervalue);
75        assertTrue("testD can not find null key", map.containsKey(null));
76        assertTrue("testD can not find a value with null key", map
77                .containsValue(anothervalue));
78        assertTrue("testD can not get value for null key",
79                map.get(null) == anothervalue);
80        assertTrue("testD put returned wrong value", result == value);
81
82        // remove a null key
83        result = map.remove(null);
84        assertTrue("testE remove returned wrong value", result == anothervalue);
85        assertTrue("testE should not find null key", !map.containsKey(null));
86        assertTrue("testE should not find a value with null key", !map
87                .containsValue(anothervalue));
88        assertNull("testE should not get value for null key",
89                map.get(null));
90    }
91
92    /**
93     * @tests java.util.IdentityHashMap#put(java.lang.Object, java.lang.Object)
94     */
95    public void test_putLjava_lang_ObjectLjava_lang_Object() {
96        IdentityHashMap<Object, Object> map = new IdentityHashMap<Object, Object>();
97
98        // Test null as a key.
99        Object value = "Some value";
100        map.put(null, value);
101        assertSame("Assert 0: Failure getting null key", value, map.get(null));
102
103        // Test null as a value
104        Object key = "Some key";
105        map.put(key, null);
106        assertNull("Assert 1: Failure getting null value", map.get(key));
107    }
108
109    /**
110     * @tests java.util.IdentityHashMap#remove(java.lang.Object)
111     * @tests java.util.IdentityHashMap#keySet()
112     */
113    public void test_remove() {
114        IdentityHashMap map = new IdentityHashMap();
115        map.put(null, null);
116        map.put("key1", "value1");
117        map.put("key2", "value2");
118        map.remove("key1");
119
120        assertTrue("Did not remove key1", !map.containsKey("key1"));
121        assertTrue("Did not remove the value for key1", !map
122                .containsValue("value1"));
123
124        assertTrue("Modified key2", map.get("key2") != null
125                && map.get("key2") == "value2");
126        assertNull("Modified null entry", map.get(null));
127    }
128
129    /**
130     * @tests java.util.IdentityHashMapTest#remove(java.lang.Object)
131     */
132    public void test_removeLjava_lang_Object() {
133        // Regression for HARMONY-37
134        IdentityHashMap<String, String> hashMap = new IdentityHashMap<String, String>();
135        hashMap.remove("absent");
136        assertEquals("Assert 0: Size is incorrect", 0, hashMap.size());
137
138        hashMap.put("key", "value");
139        hashMap.remove("key");
140        assertEquals("Assert 1: After removing non-null element size is incorrect", 0, hashMap.size());
141
142        hashMap.put(null, null);
143        assertEquals("Assert 2: adding literal null failed", 1, hashMap.size());
144        hashMap.remove(null);
145        assertEquals("Assert 3: After removing null element size is incorrect", 0, hashMap.size());
146    }
147
148    /**
149     * @tests java.util.IdentityHashMap#entrySet()
150     * @tests java.util.IdentityHashMap#keySet()
151     * @tests java.util.IdentityHashMap#values()
152     */
153    public void test_sets() {
154        // tests with null keys and values
155        IdentityHashMap map = new IdentityHashMap();
156
157        // null key and null value
158        map.put("key", "value");
159        map.put(null, null);
160        map.put("a key", null);
161        map.put("another key", null);
162
163        Set keyset = map.keySet();
164        Collection valueset = map.values();
165        Set entries = map.entrySet();
166        Iterator it = entries.iterator();
167        while (it.hasNext()) {
168            Map.Entry entry = (Map.Entry) it.next();
169            assertTrue("EntrySetIterator can not find entry ", entries
170                    .contains(entry));
171
172            assertTrue("entry key not found in map", map.containsKey(entry
173                    .getKey()));
174            assertTrue("entry value not found in map", map.containsValue(entry
175                    .getValue()));
176
177            assertTrue("entry key not found in the keyset", keyset
178                    .contains(entry.getKey()));
179            assertTrue("entry value not found in the valueset", valueset
180                    .contains(entry.getValue()));
181        }
182    }
183
184    /**
185     * @tests java.util.IdentityHashMap#entrySet()
186     * @tests java.util.IdentityHashMap#remove(java.lang.Object)
187     */
188    public void test_entrySet_removeAll() {
189        IdentityHashMap map = new IdentityHashMap();
190        for (int i = 0; i < 1000; i++) {
191            map.put(new Integer(i), new Integer(i));
192        }
193        Set set = map.entrySet();
194
195        set.removeAll(set);
196        assertEquals("did not remove all elements in the map", 0, map.size());
197        assertTrue("did not remove all elements in the entryset", set.isEmpty());
198
199        Iterator it = set.iterator();
200        assertTrue("entrySet iterator still has elements", !it.hasNext());
201    }
202
203    /**
204     * @tests java.util.IdentityHashMap#keySet()
205     * @tests java.util.IdentityHashMap#clear()
206     */
207    public void test_keySet_clear() {
208        IdentityHashMap map = new IdentityHashMap();
209        for (int i = 0; i < 1000; i++) {
210            map.put(new Integer(i), new Integer(i));
211        }
212        Set set = map.keySet();
213        set.clear();
214
215        assertEquals("did not remove all elements in the map", 0, map.size());
216        assertTrue("did not remove all elements in the keyset", set.isEmpty());
217
218        Iterator it = set.iterator();
219        assertTrue("keySet iterator still has elements", !it.hasNext());
220    }
221
222    /**
223     * @tests java.util.IdentityHashMap#values()
224     */
225    public void test_values() {
226
227        IdentityHashMap map = new IdentityHashMap();
228        for (int i = 0; i < 10; i++) {
229            map.put(new Integer(i), new Integer(i));
230        }
231
232        Integer key = new Integer(20);
233        Integer value = new Integer(40);
234        map.put(key, value);
235
236        Collection vals = map.values();
237        boolean result = vals.remove(key);
238        assertTrue("removed entries incorrectly", map.size() == 11 && !result);
239        assertTrue("removed key incorrectly", map.containsKey(key));
240        assertTrue("removed value incorrectly", map.containsValue(value));
241
242        result = vals.remove(value);
243        assertTrue("Did not remove entry as expected", map.size() == 10
244                && result);
245        assertTrue("Did not remove key as expected", !map.containsKey(key));
246        assertTrue("Did not remove value as expected", !map
247                .containsValue(value));
248
249        // put an equivalent key to a value
250        key = new Integer(1);
251        value = new Integer(100);
252        map.put(key, value);
253
254        result = vals.remove(key);
255        assertTrue("TestB. removed entries incorrectly", map.size() == 11
256                && !result);
257        assertTrue("TestB. removed key incorrectly", map.containsKey(key));
258        assertTrue("TestB. removed value incorrectly", map.containsValue(value));
259
260        result = vals.remove(value);
261        assertTrue("TestB. Did not remove entry as expected", map.size() == 10
262                && result);
263        assertTrue("TestB. Did not remove key as expected", !map
264                .containsKey(key));
265        assertTrue("TestB. Did not remove value as expected", !map
266                .containsValue(value));
267
268        vals.clear();
269        assertEquals("Did not remove all entries as expected", 0, map.size());
270    }
271
272    /**
273     * @tests java.util.IdentityHashMap#keySet()
274     * @tests java.util.IdentityHashMap#remove(java.lang.Object)
275     */
276    public void test_keySet_removeAll() {
277        IdentityHashMap map = new IdentityHashMap();
278        for (int i = 0; i < 1000; i++) {
279            map.put(new Integer(i), new Integer(i));
280        }
281        Set set = map.keySet();
282        set.removeAll(set);
283
284        assertEquals("did not remove all elements in the map", 0, map.size());
285        assertTrue("did not remove all elements in the keyset", set.isEmpty());
286
287        Iterator it = set.iterator();
288        assertTrue("keySet iterator still has elements", !it.hasNext());
289    }
290
291    /**
292     * @tests java.util.IdentityHashMap#keySet()
293     */
294    public void test_keySet_retainAll() {
295        IdentityHashMap map = new IdentityHashMap();
296        for (int i = 0; i < 1000; i++) {
297            map.put(new Integer(i), new Integer(i));
298        }
299        Set set = map.keySet();
300
301        // retain all the elements
302        boolean result = set.retainAll(set);
303        assertTrue("retain all should return false", !result);
304        assertEquals("did not retain all", 1000, set.size());
305
306        // send empty set to retainAll
307        result = set.retainAll(new TreeSet());
308        assertTrue("retain all should return true", result);
309        assertEquals("did not remove all elements in the map", 0, map.size());
310        assertTrue("did not remove all elements in the keyset", set.isEmpty());
311
312        Iterator it = set.iterator();
313        assertTrue("keySet iterator still has elements", !it.hasNext());
314    }
315
316    /**
317     * @tests java.util.IdentityHashMap#keySet()
318     * @tests java.util.IdentityHashMap#remove(java.lang.Object)
319     */
320    public void test_keyset_remove() {
321        IdentityHashMap map = new IdentityHashMap();
322
323        Integer key = new Integer(21);
324
325        map.put(new Integer(1), null);
326        map.put(new Integer(11), null);
327        map.put(key, null);
328        map.put(new Integer(31), null);
329        map.put(new Integer(41), null);
330        map.put(new Integer(51), null);
331        map.put(new Integer(61), null);
332        map.put(new Integer(71), null);
333        map.put(new Integer(81), null);
334        map.put(new Integer(91), null);
335
336        Set set = map.keySet();
337
338        Set newset = new HashSet();
339        Iterator it = set.iterator();
340        while (it.hasNext()) {
341            Object element = it.next();
342            if (element == key) {
343                it.remove();
344            } else
345                newset.add(element);
346        }
347        int size = newset.size();
348        assertTrue("keyset and newset don't have same size",
349                newset.size() == size);
350        assertTrue("element is in newset ", !newset.contains(key));
351        assertTrue("element not removed from keyset", !set.contains(key));
352        assertTrue("element not removed from map", !map.containsKey(key));
353
354        assertTrue("newset and keyset do not have same elements 1", newset
355                .equals(set));
356        assertTrue("newset and keyset do not have same elements 2", set
357                .equals(newset));
358    }
359
360    // comparator for IdentityHashMap objects
361    private static final SerializableAssert COMPARATOR = new SerializableAssert() {
362        public void assertDeserialized(Serializable initial,
363                Serializable deserialized) {
364
365            IdentityHashMap init = (IdentityHashMap) initial;
366            IdentityHashMap desr = (IdentityHashMap) deserialized;
367
368            assertEquals("Size", init.size(), desr.size());
369        }
370    };
371
372    /**
373     * @tests serialization/deserialization compatibility with RI.
374     */
375    public void testSerializationCompatibility() throws Exception {
376        IdentityHashMap<String, String> identityHashMap = new IdentityHashMap<String, String>();
377        identityHashMap.put("key1", "value1");
378        identityHashMap.put("key2", "value2");
379        identityHashMap.put("key3", "value3");
380
381        SerializationTest.verifyGolden(this, identityHashMap, COMPARATOR);
382    }
383}
384