1 package org.mozilla.geckoview.test;
2 
3 import androidx.test.filters.MediumTest;
4 import androidx.test.ext.junit.runners.AndroidJUnit4;
5 
6 import org.junit.Test;
7 import org.junit.runner.RunWith;
8 import org.mozilla.gecko.MultiMap;
9 
10 import java.util.Arrays;
11 import java.util.List;
12 import java.util.Map;
13 import java.util.Set;
14 
15 import static org.junit.Assert.assertThat;
16 import static org.hamcrest.CoreMatchers.is;
17 import static org.hamcrest.CoreMatchers.nullValue;
18 
19 @RunWith(AndroidJUnit4.class)
20 @MediumTest
21 public class MultiMapTest {
22     @Test
emptyMap()23     public void emptyMap() {
24         final MultiMap<String, String> map = new MultiMap<>();
25 
26         assertThat(map.get("not-present").isEmpty(), is(true));
27         assertThat(map.containsKey("not-present"), is(false));
28         assertThat(map.containsEntry("not-present", "nope"), is(false));
29         assertThat(map.size(), is(0));
30         assertThat(map.asMap().size(), is(0));
31         assertThat(map.remove("not-present"), nullValue());
32         assertThat(map.remove("not-present", "nope"), is(false));
33         assertThat(map.keySet().size(), is(0));
34 
35         map.clear();
36     }
37 
38     @Test
emptyMapWithCapacity()39     public void emptyMapWithCapacity() {
40         final MultiMap<String, String> map = new MultiMap<>(10);
41 
42         assertThat(map.get("not-present").isEmpty(), is(true));
43         assertThat(map.containsKey("not-present"), is(false));
44         assertThat(map.containsEntry("not-present", "nope"), is(false));
45         assertThat(map.size(), is(0));
46         assertThat(map.asMap().size(), is(0));
47         assertThat(map.remove("not-present"), nullValue());
48         assertThat(map.remove("not-present", "nope"), is(false));
49         assertThat(map.keySet().size(), is(0));
50 
51         map.clear();
52     }
53 
54     @Test
addMultipleValues()55     public void addMultipleValues() {
56         final MultiMap<String, String> map = new MultiMap<>();
57         map.add("test", "value1");
58         map.add("test", "value2");
59         map.add("test2", "value3");
60 
61         assertThat(map.containsEntry("test", "value1"), is(true));
62         assertThat(map.containsEntry("test", "value2"), is(true));
63         assertThat(map.containsEntry("test2", "value3"), is(true));
64 
65         assertThat(map.containsEntry("test3", "value1"), is(false));
66         assertThat(map.containsEntry("test", "value3"), is(false));
67 
68         final List<String> values = map.get("test");
69         assertThat(values.contains("value1"), is(true));
70         assertThat(values.contains("value2"), is(true));
71         assertThat(values.contains("value3"), is(false));
72         assertThat(values.size(), is(2));
73 
74         final List<String> values2 = map.get("test2");
75         assertThat(values2.contains("value1"), is(false));
76         assertThat(values2.contains("value2"), is(false));
77         assertThat(values2.contains("value3"), is(true));
78         assertThat(values2.size(), is(1));
79 
80         assertThat(map.size(), is(2));
81     }
82 
83     @Test
remove()84     public void remove() {
85         final MultiMap<String, String> map = new MultiMap<>();
86         map.add("test", "value1");
87         map.add("test", "value2");
88         map.add("test2", "value3");
89 
90         assertThat(map.size(), is(2));
91 
92         final List<String> values = map.remove("test");
93 
94         assertThat(values.size(), is(2));
95         assertThat(values.contains("value1"), is(true));
96         assertThat(values.contains("value2"), is(true));
97 
98         assertThat(map.size(), is(1));
99 
100         assertThat(map.containsKey("test"), is(false));
101         assertThat(map.containsEntry("test", "value1"), is(false));
102         assertThat(map.containsEntry("test", "value2"), is(false));
103         assertThat(map.get("test").size(), is(0));
104 
105         assertThat(map.get("test2").size(), is(1));
106         assertThat(map.get("test2").contains("value3"), is(true));
107         assertThat(map.containsEntry("test2", "value3"), is(true));
108     }
109 
110     @Test
removeAllValuesRemovesKey()111     public void removeAllValuesRemovesKey() {
112         final MultiMap<String, String> map = new MultiMap<>();
113         map.add("test", "value1");
114         map.add("test", "value2");
115         map.add("test2", "value3");
116 
117         assertThat(map.remove("test", "value1"), is(true));
118         assertThat(map.containsEntry("test", "value1"), is(false));
119         assertThat(map.containsEntry("test", "value2"), is(true));
120         assertThat(map.get("test").size(), is(1));
121         assertThat(map.get("test").contains("value2"), is(true));
122 
123         assertThat(map.remove("test", "value2"), is(true));
124 
125         assertThat(map.remove("test", "value3"), is(false));
126         assertThat(map.remove("test2", "value4"), is(false));
127 
128         assertThat(map.containsKey("test"), is(false));
129         assertThat(map.containsKey("test2"), is(true));
130     }
131 
132     @Test
keySet()133     public void keySet() {
134         final MultiMap<String, String> map = new MultiMap<>();
135         map.add("test", "value1");
136         map.add("test", "value2");
137         map.add("test2", "value3");
138 
139         final Set<String> keys = map.keySet();
140 
141         assertThat(keys.size(), is(2));
142         assertThat(keys.contains("test"), is(true));
143         assertThat(keys.contains("test2"), is(true));
144     }
145 
146     @Test
clear()147     public void clear() {
148         final MultiMap<String, String> map = new MultiMap<>();
149         map.add("test", "value1");
150         map.add("test", "value2");
151         map.add("test2", "value3");
152 
153         assertThat(map.size(), is(2));
154 
155         map.clear();
156 
157         assertThat(map.size(), is(0));
158         assertThat(map.containsKey("test"), is(false));
159         assertThat(map.containsKey("test2"), is(false));
160         assertThat(map.containsEntry("test", "value1"), is(false));
161         assertThat(map.containsEntry("test", "value2"), is(false));
162         assertThat(map.containsEntry("test2", "value3"), is(false));
163     }
164 
165     @Test
asMap()166     public void asMap() {
167         final MultiMap<String, String> map = new MultiMap<>();
168         map.add("test", "value1");
169         map.add("test", "value2");
170         map.add("test2", "value3");
171 
172         final Map<String, List<String>> asMap = map.asMap();
173 
174         assertThat(asMap.size(), is(2));
175 
176         assertThat(asMap.get("test").size(), is(2));
177         assertThat(asMap.get("test").contains("value1"), is(true));
178         assertThat(asMap.get("test").contains("value2"), is(true));
179 
180         assertThat(asMap.get("test2").size(), is(1));
181         assertThat(asMap.get("test2").contains("value3"), is(true));
182     }
183 
184     @Test
addAll()185     public void addAll() {
186         final MultiMap<String, String> map = new MultiMap<>();
187         map.add("test", "value1");
188 
189         assertThat(map.get("test").size(), is(1));
190 
191         // Existing key test
192         final List<String> values = map.addAll("test", Arrays.asList("value2", "value3"));
193 
194         assertThat(values.size(), is(3));
195         assertThat(values.contains("value1"), is(true));
196         assertThat(values.contains("value2"), is(true));
197         assertThat(values.contains("value3"), is(true));
198 
199         assertThat(map.containsEntry("test", "value1"), is(true));
200         assertThat(map.containsEntry("test", "value2"), is(true));
201         assertThat(map.containsEntry("test", "value3"), is(true));
202 
203         // New key test
204         final List<String> values2 = map.addAll("test2", Arrays.asList("value4", "value5"));
205         assertThat(values2.size(), is(2));
206         assertThat(values2.contains("value4"), is(true));
207         assertThat(values2.contains("value5"), is(true));
208 
209         assertThat(map.containsEntry("test2", "value4"), is(true));
210         assertThat(map.containsEntry("test2", "value5"), is(true));
211     }
212 }
213