← Back to branch summary

~ubuntu-branches/ubuntu/wily/gs-collections/wily

« back to all changes in this revision

Viewing changes to unit-tests/src/test/java/com/gs/collections/impl/map/immutable/ImmutableMapTestCase.java

  • Committer: Package Import Robot
  • Author(s): Emmanuel Bourg
  • Date: 2015-07-23 12:42:30 UTC
  • Revision ID: package-import@ubuntu.com-20150723124230-2rjvfv6elyn2m7d4
Tags: upstream-5.1.0
Import upstream version 5.1.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
unit-tests/src/test/java/com/gs/collections/impl/map/immutable/ImmutableMapTestCase.java
 
1
/*
 
2
 * Copyright 2014 Goldman Sachs.
 
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
 
 
17
package com.gs.collections.impl.map.immutable;
 
18
 
 
19
import java.util.Collections;
 
20
import java.util.HashMap;
 
21
import java.util.Iterator;
 
22
import java.util.List;
 
23
import java.util.Map;
 
24
 
 
25
import com.gs.collections.api.list.MutableList;
 
26
import com.gs.collections.api.map.ImmutableMap;
 
27
import com.gs.collections.api.map.MutableMap;
 
28
import com.gs.collections.api.set.MutableSet;
 
29
import com.gs.collections.api.tuple.Pair;
 
30
import com.gs.collections.impl.block.factory.Functions;
 
31
import com.gs.collections.impl.block.function.PassThruFunction0;
 
32
import com.gs.collections.impl.block.procedure.CollectionAddProcedure;
 
33
import com.gs.collections.impl.factory.Lists;
 
34
import com.gs.collections.impl.factory.Maps;
 
35
import com.gs.collections.impl.list.Interval;
 
36
import com.gs.collections.impl.list.fixed.ArrayAdapter;
 
37
import com.gs.collections.impl.map.mutable.UnifiedMap;
 
38
import com.gs.collections.impl.set.mutable.UnifiedSet;
 
39
import com.gs.collections.impl.test.Verify;
 
40
import com.gs.collections.impl.tuple.Tuples;
 
41
import org.junit.Assert;
 
42
import org.junit.Test;
 
43
 
 
44
/**
 
45
 * JUnit test for {@link ImmutableMap}.
 
46
 */
 
47
public abstract class ImmutableMapTestCase
 
48
{
 
49
    /**
 
50
     * @return A map containing 1 => "1", 2 => "2", etc.
 
51
     */
 
52
    protected abstract ImmutableMap<Integer, String> classUnderTest();
 
53
 
 
54
    /**
 
55
     * @return Size (and max key) of {@link #classUnderTest()}.
 
56
     */
 
57
    protected abstract int size();
 
58
 
 
59
    @Test
 
60
    public void castToMap()
 
61
    {
 
62
        ImmutableMap<Integer, String> immutable = this.classUnderTest();
 
63
        Map<Integer, String> map = immutable.castToMap();
 
64
        Assert.assertSame(immutable, map);
 
65
        Assert.assertEquals(immutable, new HashMap<Integer, String>(map));
 
66
    }
 
67
 
 
68
    @Test
 
69
    public void toMap()
 
70
    {
 
71
        ImmutableMap<Integer, String> immutable = this.classUnderTest();
 
72
        MutableMap<Integer, String> map = immutable.toMap();
 
73
        Assert.assertNotSame(immutable, map);
 
74
        Assert.assertEquals(immutable, map);
 
75
    }
 
76
 
 
77
    @Test
 
78
    public void equalsAndHashCode()
 
79
    {
 
80
        MutableMap<Integer, String> expected = this.equalUnifiedMap();
 
81
        Verify.assertEqualsAndHashCode(expected, this.classUnderTest());
 
82
        Verify.assertPostSerializedEqualsAndHashCode(this.classUnderTest());
 
83
    }
 
84
 
 
85
    @Test
 
86
    public void forEachKeyValue()
 
87
    {
 
88
        MutableSet<Integer> actualKeys = UnifiedSet.newSet();
 
89
        MutableSet<String> actualValues = UnifiedSet.newSet();
 
90
 
 
91
        this.classUnderTest().forEachKeyValue((key, value) -> {
 
92
            actualKeys.add(key);
 
93
            actualValues.add(value);
 
94
        });
 
95
 
 
96
        MutableSet<Integer> expectedKeys = this.expectedKeys();
 
97
        Assert.assertEquals(expectedKeys, actualKeys);
 
98
 
 
99
        MutableSet<String> expectedValues = expectedKeys.collect(String::valueOf);
 
100
        Assert.assertEquals(expectedValues, actualValues);
 
101
    }
 
102
 
 
103
    @Test
 
104
    public void forEachValue()
 
105
    {
 
106
        MutableSet<String> actualValues = UnifiedSet.newSet();
 
107
        this.classUnderTest().forEachValue(CollectionAddProcedure.on(actualValues));
 
108
        Assert.assertEquals(this.expectedValues(), actualValues);
 
109
    }
 
110
 
 
111
    @Test
 
112
    public void forEach()
 
113
    {
 
114
        MutableSet<String> actualValues = UnifiedSet.newSet();
 
115
        this.classUnderTest().forEach(CollectionAddProcedure.on(actualValues));
 
116
        Assert.assertEquals(this.expectedValues(), actualValues);
 
117
    }
 
118
 
 
119
    @Test
 
120
    public void flipUniqueValues()
 
121
    {
 
122
        ImmutableMap<Integer, String> immutableMap = this.classUnderTest();
 
123
        Assert.assertEquals(Interval.oneTo(this.size()).toMap(String::valueOf, Functions.getIntegerPassThru()),
 
124
                immutableMap.flipUniqueValues());
 
125
    }
 
126
 
 
127
    @Test
 
128
    public void iterator()
 
129
    {
 
130
        MutableSet<String> actualValues = UnifiedSet.newSet();
 
131
        for (String eachValue : this.classUnderTest())
 
132
        {
 
133
            actualValues.add(eachValue);
 
134
        }
 
135
        Assert.assertEquals(this.expectedValues(), actualValues);
 
136
    }
 
137
 
 
138
    @Test
 
139
    public void iteratorThrows()
 
140
    {
 
141
        Verify.assertThrows(UnsupportedOperationException.class, () -> {
 
142
            Iterator<String> iterator = this.classUnderTest().iterator();
 
143
            iterator.remove();
 
144
        });
 
145
    }
 
146
 
 
147
    @Test
 
148
    public void forEachKey()
 
149
    {
 
150
        MutableSet<Integer> actualKeys = UnifiedSet.newSet();
 
151
        this.classUnderTest().forEachKey(CollectionAddProcedure.on(actualKeys));
 
152
        Assert.assertEquals(this.expectedKeys(), actualKeys);
 
153
    }
 
154
 
 
155
    @Test
 
156
    public void get()
 
157
    {
 
158
        Integer absentKey = this.size() + 1;
 
159
        String absentValue = String.valueOf(absentKey);
 
160
 
 
161
        // Absent key behavior
 
162
        ImmutableMap<Integer, String> classUnderTest = this.classUnderTest();
 
163
        Assert.assertNull(classUnderTest.get(absentKey));
 
164
        Assert.assertFalse(classUnderTest.containsValue(absentValue));
 
165
 
 
166
        // Present key behavior
 
167
        Assert.assertEquals("1", classUnderTest.get(1));
 
168
 
 
169
        // Still unchanged
 
170
        Assert.assertEquals(this.equalUnifiedMap(), classUnderTest);
 
171
    }
 
172
 
 
173
    @Test
 
174
    public void getIfAbsent_function()
 
175
    {
 
176
        Integer absentKey = this.size() + 1;
 
177
        String absentValue = String.valueOf(absentKey);
 
178
 
 
179
        // Absent key behavior
 
180
        ImmutableMap<Integer, String> classUnderTest = this.classUnderTest();
 
181
        Assert.assertEquals(absentValue, classUnderTest.getIfAbsent(absentKey, new PassThruFunction0<String>(absentValue)));
 
182
 
 
183
        // Present key behavior
 
184
        Assert.assertEquals("1", classUnderTest.getIfAbsent(1, new PassThruFunction0<String>(absentValue)));
 
185
 
 
186
        // Still unchanged
 
187
        Assert.assertEquals(this.equalUnifiedMap(), classUnderTest);
 
188
    }
 
189
 
 
190
    @Test
 
191
    public void getIfAbsent()
 
192
    {
 
193
        Integer absentKey = this.size() + 1;
 
194
        String absentValue = String.valueOf(absentKey);
 
195
 
 
196
        // Absent key behavior
 
197
        ImmutableMap<Integer, String> classUnderTest = this.classUnderTest();
 
198
        Assert.assertEquals(absentValue, classUnderTest.getIfAbsentValue(absentKey, absentValue));
 
199
 
 
200
        // Present key behavior
 
201
        Assert.assertEquals("1", classUnderTest.getIfAbsentValue(1, absentValue));
 
202
 
 
203
        // Still unchanged
 
204
        Assert.assertEquals(this.equalUnifiedMap(), classUnderTest);
 
205
    }
 
206
 
 
207
    @Test
 
208
    public void getIfAbsentWith()
 
209
    {
 
210
        Integer absentKey = this.size() + 1;
 
211
        String absentValue = String.valueOf(absentKey);
 
212
 
 
213
        // Absent key behavior
 
214
        ImmutableMap<Integer, String> classUnderTest = this.classUnderTest();
 
215
        Assert.assertEquals(absentValue, classUnderTest.getIfAbsentWith(absentKey, String::valueOf, absentValue));
 
216
 
 
217
        // Present key behavior
 
218
        Assert.assertEquals("1", classUnderTest.getIfAbsentWith(1, String::valueOf, absentValue));
 
219
 
 
220
        // Still unchanged
 
221
        Assert.assertEquals(this.equalUnifiedMap(), classUnderTest);
 
222
    }
 
223
 
 
224
    @Test
 
225
    public void ifPresentApply()
 
226
    {
 
227
        Integer absentKey = this.size() + 1;
 
228
 
 
229
        ImmutableMap<Integer, String> classUnderTest = this.classUnderTest();
 
230
        Assert.assertNull(classUnderTest.ifPresentApply(absentKey, Functions.<String>getPassThru()));
 
231
        Assert.assertEquals("1", classUnderTest.ifPresentApply(1, Functions.<String>getPassThru()));
 
232
    }
 
233
 
 
234
    @Test
 
235
    public void notEmpty()
 
236
    {
 
237
        Assert.assertTrue(this.classUnderTest().notEmpty());
 
238
    }
 
239
 
 
240
    @Test
 
241
    public void forEachWith()
 
242
    {
 
243
        Object actualParameter = new Object();
 
244
 
 
245
        MutableSet<String> actualValues = UnifiedSet.newSet();
 
246
        MutableList<Object> actualParameters = Lists.mutable.of();
 
247
 
 
248
        this.classUnderTest().forEachWith((eachValue, parameter) -> {
 
249
            actualValues.add(eachValue);
 
250
            actualParameters.add(parameter);
 
251
        }, actualParameter);
 
252
 
 
253
        Assert.assertEquals(this.expectedKeys().collect(String::valueOf), actualValues);
 
254
        Assert.assertEquals(Collections.nCopies(this.size(), actualParameter), actualParameters);
 
255
    }
 
256
 
 
257
    @Test
 
258
    public void forEachWithIndex()
 
259
    {
 
260
        MutableSet<String> actualValues = UnifiedSet.newSet();
 
261
        MutableList<Integer> actualIndices = Lists.mutable.of();
 
262
 
 
263
        this.classUnderTest().forEachWithIndex((eachValue, index) -> {
 
264
            actualValues.add(eachValue);
 
265
            actualIndices.add(index);
 
266
        });
 
267
 
 
268
        Assert.assertEquals(this.expectedKeys().collect(String::valueOf), actualValues);
 
269
        Assert.assertEquals(this.expectedIndices(), actualIndices);
 
270
    }
 
271
 
 
272
    @Test
 
273
    public void keyValuesView()
 
274
    {
 
275
        MutableSet<Integer> actualKeys = UnifiedSet.newSet();
 
276
        MutableSet<String> actualValues = UnifiedSet.newSet();
 
277
 
 
278
        for (Pair<Integer, String> entry : this.classUnderTest().keyValuesView())
 
279
        {
 
280
            actualKeys.add(entry.getOne());
 
281
            actualValues.add(entry.getTwo());
 
282
        }
 
283
 
 
284
        MutableSet<Integer> expectedKeys = this.expectedKeys();
 
285
        Assert.assertEquals(expectedKeys, actualKeys);
 
286
 
 
287
        MutableSet<String> expectedValues = expectedKeys.collect(String::valueOf);
 
288
        Assert.assertEquals(expectedValues, actualValues);
 
289
    }
 
290
 
 
291
    @Test
 
292
    public void valuesView()
 
293
    {
 
294
        MutableSet<String> actualValues = UnifiedSet.newSet();
 
295
        for (String eachValue : this.classUnderTest().valuesView())
 
296
        {
 
297
            actualValues.add(eachValue);
 
298
        }
 
299
        MutableSet<String> expectedValues = this.expectedValues();
 
300
        Assert.assertEquals(expectedValues, actualValues);
 
301
    }
 
302
 
 
303
    @Test
 
304
    public void keysView()
 
305
    {
 
306
        MutableSet<Integer> actualKeys = UnifiedSet.newSet();
 
307
        for (Integer eachKey : this.classUnderTest().keysView())
 
308
        {
 
309
            actualKeys.add(eachKey);
 
310
        }
 
311
        Assert.assertEquals(this.expectedKeys(), actualKeys);
 
312
    }
 
313
 
 
314
    @Test
 
315
    public void putAll()
 
316
    {
 
317
        Verify.assertThrows(UnsupportedOperationException.class, () -> ((Map<Integer, String>) this.classUnderTest()).putAll(null));
 
318
    }
 
319
 
 
320
    @Test
 
321
    public void clear()
 
322
    {
 
323
        Verify.assertThrows(UnsupportedOperationException.class, () -> ((Map<Integer, String>) this.classUnderTest()).clear());
 
324
    }
 
325
 
 
326
    @Test
 
327
    public void entrySet()
 
328
    {
 
329
        ImmutableMap<Integer, String> immutable = this.classUnderTest();
 
330
        Map<Integer, String> map = new HashMap<Integer, String>(immutable.castToMap());
 
331
        Assert.assertEquals(immutable.size(), immutable.castToMap().entrySet().size());
 
332
        Assert.assertEquals(map.entrySet(), immutable.castToMap().entrySet());
 
333
    }
 
334
 
 
335
    @Test
 
336
    public void newWithKeyValue()
 
337
    {
 
338
        ImmutableMap<Integer, String> immutable = this.classUnderTest();
 
339
        ImmutableMap<Integer, String> immutable2 = immutable.newWithKeyValue(Integer.MAX_VALUE, Integer.toString(Integer.MAX_VALUE));
 
340
        Verify.assertSize(immutable.size() + 1, immutable2);
 
341
    }
 
342
 
 
343
    @Test
 
344
    public void newWithAllKeyValuePairs()
 
345
    {
 
346
        ImmutableMap<Integer, String> immutable = this.classUnderTest();
 
347
        ImmutableMap<Integer, String> immutable2 = immutable.newWithAllKeyValueArguments(
 
348
                Tuples.pair(Integer.MAX_VALUE, Integer.toString(Integer.MAX_VALUE)),
 
349
                Tuples.pair(Integer.MIN_VALUE, Integer.toString(Integer.MIN_VALUE)));
 
350
        Verify.assertSize(immutable.size() + 2, immutable2);
 
351
    }
 
352
 
 
353
    @Test
 
354
    public void newWithAllKeyValues()
 
355
    {
 
356
        ImmutableMap<Integer, String> immutable = this.classUnderTest();
 
357
        ImmutableMap<Integer, String> immutable2 = immutable.newWithAllKeyValues(ArrayAdapter.newArrayWith(
 
358
                Tuples.pair(Integer.MAX_VALUE, Integer.toString(Integer.MAX_VALUE)),
 
359
                Tuples.pair(Integer.MIN_VALUE, Integer.toString(Integer.MIN_VALUE))));
 
360
        Verify.assertSize(immutable.size() + 2, immutable2);
 
361
    }
 
362
 
 
363
    @Test
 
364
    public void newWithoutKey()
 
365
    {
 
366
        ImmutableMap<Integer, String> immutable = this.classUnderTest();
 
367
        ImmutableMap<Integer, String> immutable3 = immutable.newWithoutKey(Integer.MAX_VALUE);
 
368
        Verify.assertSize(immutable.size(), immutable3);
 
369
    }
 
370
 
 
371
    @Test
 
372
    public void newWithoutKeys()
 
373
    {
 
374
        ImmutableMap<Integer, String> immutable = this.classUnderTest();
 
375
        ImmutableMap<Integer, String> immutable2 = immutable.newWithoutAllKeys(immutable.keysView());
 
376
        ImmutableMap<Integer, String> immutable3 = immutable.newWithoutAllKeys(Lists.immutable.<Integer>of());
 
377
        Assert.assertEquals(immutable, immutable3);
 
378
        Assert.assertEquals(Maps.immutable.of(), immutable2);
 
379
    }
 
380
 
 
381
    @Test
 
382
    public void put()
 
383
    {
 
384
        Verify.assertThrows(UnsupportedOperationException.class, () -> {
 
385
            ((Map<Integer, String>) this.classUnderTest()).put(null, null);
 
386
        });
 
387
    }
 
388
 
 
389
    @Test
 
390
    public void remove()
 
391
    {
 
392
        Verify.assertThrows(UnsupportedOperationException.class, () -> {
 
393
            ((Map<Integer, String>) this.classUnderTest()).remove(null);
 
394
        });
 
395
    }
 
396
 
 
397
    @Test
 
398
    public abstract void testToString();
 
399
 
 
400
    protected MutableMap<Integer, String> equalUnifiedMap()
 
401
    {
 
402
        MutableMap<Integer, String> expected = UnifiedMap.newMap();
 
403
        for (int i = 1; i <= this.size(); i++)
 
404
        {
 
405
            expected.put(i, String.valueOf(i));
 
406
        }
 
407
        return expected;
 
408
    }
 
409
 
 
410
    private MutableSet<String> expectedValues()
 
411
    {
 
412
        return this.expectedKeys().collect(String::valueOf);
 
413
    }
 
414
 
 
415
    private MutableSet<Integer> expectedKeys()
 
416
    {
 
417
        if (this.size() == 0)
 
418
        {
 
419
            return UnifiedSet.newSet();
 
420
        }
 
421
        return Interval.oneTo(this.size()).toSet();
 
422
    }
 
423
 
 
424
    private List<Integer> expectedIndices()
 
425
    {
 
426
        if (this.size() == 0)
 
427
        {
 
428
            return Lists.mutable.of();
 
429
        }
 
430
        return Interval.zeroTo(this.size() - 1);
 
431
    }
 
432
}