1/*
2 * Copyright (C) 2017 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 androidx.collection
18
19import androidx.testutils.fail
20import com.google.common.truth.Truth.assertThat
21import org.junit.Assert.assertEquals
22import org.junit.Assert.assertFalse
23import org.junit.Assert.assertSame
24import org.junit.Assert.assertTrue
25import org.junit.Test
26
27class SparseArrayCompatTest {
28    @Test fun sizeProperty() {
29        val array = SparseArrayCompat<String>()
30        assertEquals(0, array.size)
31        array.put(1, "one")
32        assertEquals(1, array.size)
33    }
34
35    @Test fun containsOperator() {
36        val array = SparseArrayCompat<String>()
37        assertFalse(1 in array)
38        array.put(1, "one")
39        assertTrue(1 in array)
40    }
41
42    @Test fun containsOperatorWithItem() {
43        val array = SparseArrayCompat<String>()
44
45        array.put(1, "one")
46        assertFalse(2 in array)
47
48        array.put(2, "two")
49        assertTrue(2 in array)
50    }
51
52    @Test fun setOperator() {
53        val array = SparseArrayCompat<String>()
54        array[1] = "one"
55        assertEquals("one", array.get(1))
56    }
57
58    @Test fun plusOperator() {
59        val first = SparseArrayCompat<String>().apply { put(1, "one") }
60        val second = SparseArrayCompat<String>().apply { put(2, "two") }
61        val combined = first + second
62        assertEquals(2, combined.size())
63        assertEquals(1, combined.keyAt(0))
64        assertEquals("one", combined.valueAt(0))
65        assertEquals(2, combined.keyAt(1))
66        assertEquals("two", combined.valueAt(1))
67    }
68
69    @Test fun containsKey() {
70        val array = SparseArrayCompat<String>()
71        assertFalse(array.containsKey(1))
72        array.put(1, "one")
73        assertTrue(array.containsKey(1))
74    }
75
76    @Test fun containsValue() {
77        val array = SparseArrayCompat<String>()
78        assertFalse(array.containsValue("one"))
79        array.put(1, "one")
80        assertTrue(array.containsValue("one"))
81    }
82
83    @Test fun getOrDefault() {
84        val array = SparseArrayCompat<Any>()
85        val default = Any()
86        assertSame(default, array.getOrDefault(1, default))
87        array.put(1, "one")
88        assertEquals("one", array.getOrDefault(1, default))
89    }
90
91    @Test fun getOrElse() {
92        val array = SparseArrayCompat<Any>()
93        val default = Any()
94        assertSame(default, array.getOrElse(1) { default })
95        array.put(1, "one")
96        assertEquals("one", array.getOrElse(1) { fail() })
97    }
98
99    @Test fun isNotEmpty() {
100        val array = SparseArrayCompat<String>()
101        assertFalse(array.isNotEmpty())
102        array.put(1, "one")
103        assertTrue(array.isNotEmpty())
104    }
105
106    @Test fun removeValue() {
107        val array = SparseArrayCompat<String>()
108        array.put(1, "one")
109        assertFalse(array.remove(0, "one"))
110        assertEquals(1, array.size())
111        assertFalse(array.remove(1, "two"))
112        assertEquals(1, array.size())
113        assertTrue(array.remove(1, "one"))
114        assertEquals(0, array.size())
115    }
116
117    @Test fun putAll() {
118        val dest = SparseArrayCompat<String>()
119        val source = SparseArrayCompat<String>()
120        source.put(1, "one")
121
122        assertEquals(0, dest.size())
123        dest.putAll(source)
124        assertEquals(1, dest.size())
125    }
126
127    @Test fun forEach() {
128        val array = SparseArrayCompat<String>()
129        array.forEach { _, _ -> fail() }
130
131        array.put(1, "one")
132        array.put(2, "two")
133        array.put(6, "six")
134
135        val keys = mutableListOf<Int>()
136        val values = mutableListOf<String>()
137        array.forEach { key, value ->
138            keys.add(key)
139            values.add(value)
140        }
141        assertThat(keys).containsExactly(1, 2, 6)
142        assertThat(values).containsExactly("one", "two", "six")
143    }
144
145    @Test fun keyIterator() {
146        val array = SparseArrayCompat<String>()
147        assertFalse(array.keyIterator().hasNext())
148
149        array.put(1, "one")
150        array.put(2, "two")
151        array.put(6, "six")
152
153        val iterator = array.keyIterator()
154        assertTrue(iterator.hasNext())
155        assertEquals(1, iterator.nextInt())
156        assertTrue(iterator.hasNext())
157        assertEquals(2, iterator.nextInt())
158        assertTrue(iterator.hasNext())
159        assertEquals(6, iterator.nextInt())
160        assertFalse(iterator.hasNext())
161    }
162
163    @Test fun valueIterator() {
164        val array = SparseArrayCompat<String>()
165        assertFalse(array.valueIterator().hasNext())
166
167        array.put(1, "one")
168        array.put(2, "two")
169        array.put(6, "six")
170
171        val iterator = array.valueIterator()
172        assertTrue(iterator.hasNext())
173        assertEquals("one", iterator.next())
174        assertTrue(iterator.hasNext())
175        assertEquals("two", iterator.next())
176        assertTrue(iterator.hasNext())
177        assertEquals("six", iterator.next())
178        assertFalse(iterator.hasNext())
179    }
180}
181