LinkedHashMapTest.java revision fca5aaa0a2c31d322b708012df2158d8399cefe3 
1/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License
15 */
16
17package libcore.java.util;
18
19import java.util.LinkedHashMap;
20import java.util.Map;
21import java.util.concurrent.atomic.AtomicBoolean;
22import java.util.concurrent.atomic.AtomicInteger;
23
24public class LinkedHashMapTest extends junit.framework.TestCase {
25
26    public void test_getOrDefault() {
27        MapDefaultMethodTester
28                .test_getOrDefault(new LinkedHashMap<>(), true /*acceptsNullKey*/,
29                        true /*acceptsNullValue*/);
30
31        // Test for access order
32        Map<String, String> m = new LinkedHashMap<String, String>(8, .75f, true);
33        m.put("key", "value");
34        m.put("key1", "value1");
35        m.put("key2", "value2");
36        m.getOrDefault("key1", "value");
37        Map.Entry<String, String> newest = null;
38        for (Map.Entry<String, String> e : m.entrySet()) {
39            newest = e;
40        }
41        assertEquals("key1", newest.getKey());
42        assertEquals("value1", newest.getValue());
43    }
44
45    public void test_forEach() {
46        MapDefaultMethodTester.test_forEach(new LinkedHashMap<>());
47    }
48
49    public void test_putIfAbsent() {
50        MapDefaultMethodTester.test_putIfAbsent(new LinkedHashMap<>(), true /*acceptsNullKey*/,
51                true /*acceptsNullValue*/);
52
53        // Test for access order
54        Map<String, String> m = new LinkedHashMap<String, String>(8, .75f, true);
55        m.putIfAbsent("key", "value");
56        m.putIfAbsent("key1", "value1");
57        m.putIfAbsent("key2", "value2");
58        Map.Entry<String, String> newest = null;
59        for (Map.Entry<String, String> e : m.entrySet()) {
60            newest = e;
61        }
62        assertEquals("key2", newest.getKey());
63        assertEquals("value2", newest.getValue());
64
65        // for existed key
66        m.putIfAbsent("key1", "value1");
67        for (Map.Entry<String, String> e : m.entrySet()) {
68            newest = e;
69        }
70        assertEquals("key1", newest.getKey());
71        assertEquals("value1", newest.getValue());
72    }
73
74    public void test_remove() {
75        MapDefaultMethodTester.test_remove(new LinkedHashMap<>(), true /*acceptsNullKey*/,
76                true /*acceptsNullValue*/);
77    }
78
79    public void test_replace$K$V$V() {
80        MapDefaultMethodTester.
81                test_replace$K$V$V(new LinkedHashMap<>(), true /*acceptsNullKey*/,
82                        true /*acceptsNullValue*/);
83
84        // Test for access order
85        Map<String, String> m = new LinkedHashMap<>(8, .75f, true  /*accessOrder*/);
86        m.put("key", "value");
87        m.put("key1", "value1");
88        m.put("key2", "value2");
89        m.replace("key1", "value1", "value2");
90        Map.Entry<String, String> newest = null;
91        for (Map.Entry<String, String> e : m.entrySet()) {
92            newest = e;
93        }
94        assertEquals("key1", newest.getKey());
95        assertEquals("value2", newest.getValue());
96
97        // for wrong pair of key and value, last accessed node should
98        // not change
99        m.replace("key2", "value1", "value3");
100        for (Map.Entry<String, String> e : m.entrySet()) {
101            newest = e;
102        }
103        assertEquals("key1", newest.getKey());
104        assertEquals("value2", newest.getValue());
105    }
106
107    public void test_replace$K$V() {
108        MapDefaultMethodTester.test_replace$K$V(new LinkedHashMap<>(), true /*acceptsNullKey*/,
109                true /*acceptsNullValue*/);
110
111        // Test for access order
112        Map<String, String> m = new LinkedHashMap<>(8, .75f, true  /*accessOrder*/);
113        m.put("key", "value");
114        m.put("key1", "value1");
115        m.put("key2", "value2");
116        m.replace("key1", "value2");
117        Map.Entry<String, String> newest = null;
118        for (Map.Entry<String, String> e : m.entrySet()) {
119            newest = e;
120        }
121        assertEquals("key1", newest.getKey());
122        assertEquals("value2", newest.getValue());
123    }
124
125    public void test_computeIfAbsent() {
126        MapDefaultMethodTester.test_computeIfAbsent(new LinkedHashMap<>(), true /*acceptsNullKey*/,
127                true /*acceptsNullValue*/);
128
129        // Test for access order
130        Map<String, String> m = new LinkedHashMap<>(8, .75f, true  /*accessOrder*/);
131        m.put("key", "value");
132        m.put("key1", "value1");
133        m.put("key2", "value2");
134        m.computeIfAbsent("key1", (k) -> "value3");
135        Map.Entry<String, String> newest = null;
136        for (Map.Entry<String, String> e : m.entrySet()) {
137            newest = e;
138        }
139        assertEquals("key1", newest.getKey());
140        assertEquals("value1", newest.getValue());
141
142        // When value is absent
143        m.computeIfAbsent("key4", (k) -> "value3");
144        newest = null;
145        for (Map.Entry<String, String> e : m.entrySet()) {
146            newest = e;
147        }
148        assertEquals("key4", newest.getKey());
149        assertEquals("value3", newest.getValue());
150    }
151
152    public void test_computeIfPresent() {
153        MapDefaultMethodTester.test_computeIfPresent(new LinkedHashMap<>(), true /*acceptsNullKey*/);
154
155        // Test for access order
156        Map<String, String> m = new LinkedHashMap<>(8, .75f, true  /*accessOrder*/);
157        m.put("key", "value");
158        m.put("key1", "value1");
159        m.put("key2", "value2");
160        m.computeIfPresent("key1", (k, v) -> "value3");
161        Map.Entry<String, String> newest = null;
162        for (Map.Entry<String, String> e : m.entrySet()) {
163            newest = e;
164        }
165        assertEquals("key1", newest.getKey());
166        assertEquals("value3", newest.getValue());
167    }
168
169    public void test_compute() {
170        MapDefaultMethodTester.test_compute(new LinkedHashMap<>(), true /*acceptsNullKey*/);
171
172        // Test for access order
173        Map<String, String> m = new LinkedHashMap<>(8, .75f, true  /*accessOrder*/);
174        m.put("key", "value");
175        m.put("key1", "value1");
176        m.put("key2", "value2");
177        m.compute("key1", (k, v) -> "value3");
178        Map.Entry<String, String> newest = null;
179        for (Map.Entry<String, String> e : m.entrySet()) {
180            newest = e;
181        }
182        assertEquals("key1", newest.getKey());
183        assertEquals("value3", newest.getValue());
184
185        m.compute("key4", (k, v) -> "value4");
186        newest = null;
187        for (Map.Entry<String, String> e : m.entrySet()) {
188            newest = e;
189        }
190        assertEquals("key4", newest.getKey());
191        assertEquals("value4", newest.getValue());
192    }
193
194    public void test_merge() {
195        MapDefaultMethodTester.test_merge(new LinkedHashMap<>(), true /*acceptsNullKey*/);
196
197        // Test for access order
198        Map<String, String> m = new LinkedHashMap<>(8, .75f, true  /*accessOrder*/);
199        m.put("key", "value");
200        m.put("key1", "value1");
201        m.put("key2", "value2");
202        m.merge("key1", "value3", (k, v) -> "value3");
203        Map.Entry<String, String> newest = null;
204        for (Map.Entry<String, String> e : m.entrySet()) {
205            newest = e;
206        }
207        assertEquals("key1", newest.getKey());
208        assertEquals("value3", newest.getValue());
209    }
210
211    // http://b/27929722
212    // This tests the behaviour is consistent with earlier Android releases.
213    // This behaviour is NOT consistent with the RI. Future Android releases
214    // might change this.
215    public void test_removeEldestEntry() {
216        final AtomicBoolean removeEldestEntryReturnValue = new AtomicBoolean(false);
217        final AtomicInteger removeEldestEntryCallCount = new AtomicInteger(0);
218        LinkedHashMap<String, String> m = new LinkedHashMap<String, String>() {
219            @Override
220            protected boolean removeEldestEntry(Entry eldest) {
221                removeEldestEntryCallCount.incrementAndGet();
222                return removeEldestEntryReturnValue.get();
223            }
224        };
225
226        m.put("foo", "bar");
227        assertEquals(0, removeEldestEntryCallCount.get());
228        m.put("baz", "quux");
229        assertEquals(1, removeEldestEntryCallCount.get());
230
231        removeEldestEntryReturnValue.set(true);
232        m.put("foob", "faab");
233        assertEquals(2, removeEldestEntryCallCount.get());
234        assertEquals(2, m.size());
235        assertFalse(m.containsKey("foo"));
236    }
237}
238