1/*
2 * Copyright 2018 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 */
16package androidx.collection;
17
18import static org.junit.Assert.assertFalse;
19import static org.junit.Assert.assertTrue;
20import static org.junit.Assert.fail;
21
22import org.junit.Test;
23
24import java.util.AbstractMap;
25import java.util.Arrays;
26import java.util.HashSet;
27import java.util.Iterator;
28import java.util.Map;
29import java.util.NoSuchElementException;
30import java.util.Set;
31
32public class ArrayMapCompatTest {
33
34    @Test
35    public void testCanNotIteratePastEnd_entrySetIterator() {
36        Map<String, String> map = new ArrayMap<>();
37        map.put("key 1", "value 1");
38        map.put("key 2", "value 2");
39        Set<Map.Entry<String, String>> expectedEntriesToIterate = new HashSet<>(Arrays.asList(
40                entryOf("key 1", "value 1"),
41                entryOf("key 2", "value 2")
42        ));
43        Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
44
45        // Assert iteration over the expected two entries in any order
46        assertTrue(iterator.hasNext());
47        Map.Entry<String, String> firstEntry = copyOf(iterator.next());
48        assertTrue(expectedEntriesToIterate.remove(firstEntry));
49
50        assertTrue(iterator.hasNext());
51        Map.Entry<String, String> secondEntry = copyOf(iterator.next());
52        assertTrue(expectedEntriesToIterate.remove(secondEntry));
53
54        assertFalse(iterator.hasNext());
55
56        try {
57            iterator.next();
58            fail();
59        } catch (NoSuchElementException expected) {
60        }
61    }
62
63    private static <K, V> Map.Entry<K, V> entryOf(K key, V value) {
64        return new AbstractMap.SimpleEntry<>(key, value);
65    }
66
67    private static <K, V> Map.Entry<K, V> copyOf(Map.Entry<K, V> entry) {
68        return entryOf(entry.getKey(), entry.getValue());
69    }
70
71    @Test
72    public void testCanNotIteratePastEnd_keySetIterator() {
73        Map<String, String> map = new ArrayMap<>();
74        map.put("key 1", "value 1");
75        map.put("key 2", "value 2");
76        Set<String> expectedKeysToIterate = new HashSet<>(Arrays.asList("key 1", "key 2"));
77        Iterator<String> iterator = map.keySet().iterator();
78
79        // Assert iteration over the expected two keys in any order
80        assertTrue(iterator.hasNext());
81        String firstKey = iterator.next();
82        assertTrue(expectedKeysToIterate.remove(firstKey));
83
84        assertTrue(iterator.hasNext());
85        String secondKey = iterator.next();
86        assertTrue(expectedKeysToIterate.remove(secondKey));
87
88        assertFalse(iterator.hasNext());
89
90        try {
91            iterator.next();
92            fail();
93        } catch (NoSuchElementException expected) {
94        }
95    }
96
97    @Test
98    public void testCanNotIteratePastEnd_valuesIterator() {
99        Map<String, String> map = new ArrayMap<>();
100        map.put("key 1", "value 1");
101        map.put("key 2", "value 2");
102        Set<String> expectedValuesToIterate = new HashSet<>(Arrays.asList("value 1", "value 2"));
103        Iterator<String> iterator = map.values().iterator();
104
105        // Assert iteration over the expected two values in any order
106        assertTrue(iterator.hasNext());
107        String firstValue = iterator.next();
108        assertTrue(expectedValuesToIterate.remove(firstValue));
109
110        assertTrue(iterator.hasNext());
111        String secondValue = iterator.next();
112        assertTrue(expectedValuesToIterate.remove(secondValue));
113
114        assertFalse(iterator.hasNext());
115
116        try {
117            iterator.next();
118            fail();
119        } catch (NoSuchElementException expected) {
120        }
121    }
122}
123