View Javadoc
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  package org.apache.commons.collections4.multimap;
18  
19  import static org.junit.jupiter.api.Assertions.assertEquals;
20  import static org.junit.jupiter.api.Assertions.assertFalse;
21  import static org.junit.jupiter.api.Assertions.assertNotSame;
22  import static org.junit.jupiter.api.Assertions.assertTrue;
23  
24  import java.util.ArrayList;
25  import java.util.Arrays;
26  import java.util.HashMap;
27  import java.util.List;
28  import java.util.ListIterator;
29  import java.util.Map;
30  
31  import org.apache.commons.collections4.ListValuedMap;
32  import org.apache.commons.collections4.MapIterator;
33  import org.apache.commons.collections4.MultiValuedMap;
34  import org.apache.commons.collections4.collection.AbstractCollectionTest;
35  import org.junit.jupiter.api.Test;
36  
37  /**
38   * Tests {@link ArrayListValuedLinkedHashMap}.
39   */
40  public class ArrayListValuedLinkedHashMapTest<K, V> extends AbstractMultiValuedMapTest<K, V> {
41  
42      @Override
43      public String getCompatibilityVersion() {
44          return "4.5"; // ArrayListValuedLinkedHashMap has been added in version 4.5
45      }
46  
47      @Override
48      protected int getIterationBehaviour() {
49          return AbstractCollectionTest.UNORDERED;
50      }
51  
52      @Override
53      public ListValuedMap<K, V> makeObject() {
54          return new ArrayListValuedLinkedHashMap<>();
55      }
56  
57      @Test
58      public void testArrayListValuedLinkedHashMap() {
59          final ListValuedMap<K, V> listMap;
60          final ListValuedMap<K, V> listMap1;
61          final Map<K, V> map = new HashMap<>();
62          final Map<K, V> map1 = new HashMap<>();
63          map.put((K) "A", (V) "W");
64          map.put((K) "B", (V) "X");
65          map.put((K) "C", (V) "F");
66  
67          listMap = new ArrayListValuedLinkedHashMap<>(map);
68          assertEquals(1, listMap.get((K) "A").size());
69          assertEquals(1, listMap.get((K) "B").size());
70          assertEquals(1, listMap.get((K) "C").size());
71  
72          listMap1 = new ArrayListValuedLinkedHashMap<>(map1);
73          assertEquals("{}", listMap1.toString());
74      }
75  
76      @Test
77      public void testCopyConstructorWithMultiValuedMap() {
78          final ListValuedMap<K, V> map = makeObject();
79          map.put((K) "key", (V) "sleutel");
80          final ListValuedMap<K, V> copy = new ArrayListValuedLinkedHashMap<>(map);
81          assertEquals(map, copy);
82      }
83  
84      @SuppressWarnings({ "unchecked", "rawtypes" })
85      @Test
86      public void testEqualsHashCodeContract() {
87          final MultiValuedMap map1 = makeObject();
88          final MultiValuedMap map2 = makeObject();
89  
90          map1.put("a", "a1");
91          map1.put("a", "a2");
92          map2.put("a", "a1");
93          map2.put("a", "a2");
94          assertEquals(map1, map2);
95          assertEquals(map1.hashCode(), map2.hashCode());
96  
97          map2.put("a", "a2");
98          assertNotSame(map1, map2);
99          assertNotSame(map1.hashCode(), map2.hashCode());
100     }
101 
102     @Test
103     @SuppressWarnings("unchecked")
104     public void testListValuedMapAdd() {
105         final ListValuedMap<K, V> listMap = makeObject();
106         assertTrue(listMap.get((K) "whatever") instanceof List);
107         final List<V> list = listMap.get((K) "A");
108         list.add((V) "a1");
109         assertEquals(1, listMap.size());
110         assertTrue(listMap.containsKey("A"));
111     }
112 
113     @Test
114     @SuppressWarnings("unchecked")
115     public void testListValuedMapAddViaListIterator() {
116         final ListValuedMap<K, V> listMap = makeObject();
117         final ListIterator<V> listIt = listMap.get((K) "B").listIterator();
118         assertFalse(listIt.hasNext());
119         listIt.add((V) "b1");
120         listIt.add((V) "b2");
121         listIt.add((V) "b3");
122         assertEquals(3, listMap.size());
123         assertTrue(listMap.containsKey("B"));
124         // As ListIterator always adds before the current cursor
125         assertFalse(listIt.hasNext());
126     }
127 
128     @SuppressWarnings({ "unchecked", "rawtypes" })
129     @Test
130     public void testListValuedMapEqualsHashCodeContract() {
131         final ListValuedMap map1 = makeObject();
132         final ListValuedMap map2 = makeObject();
133 
134         map1.put("a", "a1");
135         map1.put("a", "a2");
136         map2.put("a", "a1");
137         map2.put("a", "a2");
138         assertEquals(map1, map2);
139         assertEquals(map1.hashCode(), map2.hashCode());
140 
141         map1.put("b", "b1");
142         map1.put("b", "b2");
143         map2.put("b", "b2");
144         map2.put("b", "b1");
145         assertNotSame(map1, map2);
146         assertNotSame(map1.hashCode(), map2.hashCode());
147     }
148 
149     @Test
150     @SuppressWarnings("unchecked")
151     public void testListValuedMapRemove() {
152         final ListValuedMap<K, V> listMap = makeObject();
153         final List<V> list = listMap.get((K) "A");
154         list.add((V) "a1");
155         list.add((V) "a2");
156         list.add((V) "a3");
157         assertEquals(3, listMap.size());
158         assertEquals("a1", list.remove(0));
159         assertEquals(2, listMap.size());
160         assertEquals("a2", list.remove(0));
161         assertEquals(1, listMap.size());
162         assertEquals("a3", list.remove(0));
163         assertEquals(0, listMap.size());
164         assertFalse(listMap.containsKey("A"));
165     }
166 
167     @Test
168     @SuppressWarnings("unchecked")
169     public void testListValuedMapRemoveViaListIterator() {
170         final ListValuedMap<K, V> listMap = makeObject();
171         ListIterator<V> listIt = listMap.get((K) "B").listIterator();
172         listIt.add((V) "b1");
173         listIt.add((V) "b2");
174         assertEquals(2, listMap.size());
175         assertTrue(listMap.containsKey("B"));
176         listIt = listMap.get((K) "B").listIterator();
177         while (listIt.hasNext()) {
178             listIt.next();
179             listIt.remove();
180         }
181         assertFalse(listMap.containsKey("B"));
182         listIt.add((V) "b1");
183         listIt.add((V) "b2");
184         assertTrue(listMap.containsKey("B"));
185         assertEquals(2, listMap.get((K) "B").size());
186     }
187 
188     @Test
189     public void testPreservesKeyInsertionOrder() {
190         final ListValuedMap<K, V> map = makeObject();
191         map.put((K) Integer.valueOf(5), (V) "five");
192         map.put((K) Integer.valueOf(1), (V) "one");
193         map.put((K) Integer.valueOf(5), (V) "vijf"); // "vijf" = "five" in Dutch
194         final MapIterator<K, V> mapIterator = map.mapIterator();
195         assertEquals(5, mapIterator.next());
196         assertEquals("five", mapIterator.getValue());
197         assertEquals(5, mapIterator.next());
198         assertEquals("vijf", mapIterator.getValue());
199         assertEquals(1, mapIterator.next());
200         assertEquals("one", mapIterator.getValue());
201         assertFalse(mapIterator.hasNext());
202     }
203 
204     @Test
205     public void testTrimToSize() {
206         final ArrayListValuedLinkedHashMap<K, V> listMap = new ArrayListValuedLinkedHashMap<>(4);
207 
208         assertEquals("{}", listMap.toString());
209         listMap.put((K) "A", (V) "W");
210         listMap.put((K) "A", (V) "X");
211         listMap.put((K) "B", (V) "F");
212         assertEquals(2, listMap.get((K) "A").size());
213         assertEquals(1, listMap.get((K) "B").size());
214 
215         listMap.trimToSize();
216         assertEquals(2, listMap.get((K) "A").size());
217         assertEquals(1, listMap.get((K) "B").size());
218     }
219 
220     @Test
221     public void testValuesListIteratorMethods() {
222         final ListValuedMap<K, V> listMap = makeObject();
223         final List<V> listA = listMap.get((K) "A");
224         final List<V> list = Arrays.asList((V) "W", (V) "X", (V) "F", (V) "Q", (V) "Q", (V) "F");
225         listA.addAll(0, list);
226         final ListIterator<V> it = listMap.get((K) "A").listIterator(1);
227         assertTrue(it.hasNext());
228         assertEquals("X", it.next());
229         assertEquals("F", it.next());
230         assertTrue(it.hasPrevious());
231         assertEquals("F", it.previous());
232         assertEquals(2, it.nextIndex());
233         assertEquals(1, it.previousIndex());
234         it.set((V) "Z");
235         assertEquals("Z", it.next());
236         assertEquals("Q", it.next());
237     }
238 
239     @Test
240     public void testWrappedListAdd() {
241         final ListValuedMap<K, V> listMap = makeObject();
242         final List<V> listA = listMap.get((K) "A");
243         listA.add(0, (V) "W");
244         listA.add(1, (V) "X");
245         listA.add(2, (V) "F");
246         assertEquals("{A=[W, X, F]}", listMap.toString());
247         listMap.get((K) "A").set(1, (V) "Q");
248         assertEquals("{A=[W, Q, F]}", listMap.toString());
249     }
250 
251     @Test
252     public void testWrappedListAddAll() {
253         final ListValuedMap<K, V> listMap = makeObject();
254         final List<V> listA = listMap.get((K) "A");
255         final List<V> list = Arrays.asList((V) "W", (V) "X", (V) "F");
256         listA.addAll(0, list);
257         assertEquals("{A=[W, X, F]}", listMap.toString());
258 
259         final List<V> list1 = Arrays.asList((V) "Q", (V) "Q", (V) "L");
260         listA.addAll(3, list1);
261         assertEquals("{A=[W, X, F, Q, Q, L]}", listMap.toString());
262         assertEquals("W", listMap.get((K) "A").get(0));
263         assertEquals("X", listMap.get((K) "A").get(1));
264         assertEquals("F", listMap.get((K) "A").get(2));
265         assertEquals("Q", listMap.get((K) "A").get(3));
266         assertEquals("Q", listMap.get((K) "A").get(4));
267         assertEquals("L", listMap.get((K) "A").get(5));
268         assertEquals(0, listMap.get((K) "A").indexOf("W"));
269         assertEquals(2, listMap.get((K) "A").indexOf("F"));
270         assertEquals(-1, listMap.get((K) "A").indexOf("C"));
271         assertEquals(3, listMap.get((K) "A").indexOf("Q"));
272         assertEquals(4, listMap.get((K) "A").lastIndexOf("Q"));
273         assertEquals(-1, listMap.get((K) "A").lastIndexOf("A"));
274 
275         final List<V> list2 = new ArrayList<>();
276         listMap.get((K) "B").addAll(0, list2);
277         assertEquals("{A=[W, X, F, Q, Q, L]}", listMap.toString());
278         final List<V> list3 = listMap.get((K) "A").subList(1, 4);
279         assertEquals(3, list3.size());
280         assertEquals("Q", list3.get(2));
281     }
282 
283 //    @Test
284 //    public void testCreate() throws Exception {
285 //        writeExternalFormToDisk((java.io.Serializable) makeObject(),
286 //                "src/test/resources/org/apache/commons/collections4/data/test/ArrayListValuedLinkedHashMap.emptyCollection.version4.5.obj");
287 //        writeExternalFormToDisk((java.io.Serializable) makeFullMap(),
288 //                "src/test/resources/org/apache/commons/collections4/data/test/ArrayListValuedLinkedHashMap.fullCollection.version4.5.obj");
289 //    }
290 
291 }