1 /*
2  * Copyright (C) 2021 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 
17 package com.android.net.module.util
18 
19 import android.util.SparseArray
20 import androidx.test.filters.SmallTest
21 import androidx.test.runner.AndroidJUnit4
22 import com.android.testutils.assertThrows
23 import org.junit.Test
24 import org.junit.runner.RunWith
25 import kotlin.test.assertEquals
26 import kotlin.test.assertFailsWith
27 import kotlin.test.assertFalse
28 import kotlin.test.assertNull
29 import kotlin.test.assertSame
30 import kotlin.test.assertTrue
31 
32 @RunWith(AndroidJUnit4::class)
33 @SmallTest
34 class CollectionUtilsTest {
35     @Test
testAnynull36     fun testAny() {
37         assertTrue(CollectionUtils.any(listOf("A", "B", "C", "D", "E")) { it == "E" })
38         assertFalse(CollectionUtils.any(listOf("A", "B", "C", "D", "E")) { it == "F" })
39         assertTrue(CollectionUtils.any(listOf("AA", "BBB")) { it.length >= 3 })
40         assertFalse(CollectionUtils.any(listOf("A", "BB", "CCC")) { it.length >= 4 })
41         assertFalse(CollectionUtils.any(listOf("A", "BB", "CCC")) { it.length < 0 })
42         assertFalse(CollectionUtils.any(listOf<String>()) { true })
43         assertFalse(CollectionUtils.any(listOf<String>()) { false })
44         assertTrue(CollectionUtils.any(listOf("A")) { true })
45         assertFalse(CollectionUtils.any(listOf("A")) { false })
46     }
47 
48     @Test
testIndexOfnull49     fun testIndexOf() {
50         assertEquals(4, CollectionUtils.indexOf(listOf("A", "B", "C", "D", "E")) { it == "E" })
51         assertEquals(0, CollectionUtils.indexOf(listOf("A", "B", "C", "D", "E")) { it == "A" })
52         assertEquals(1, CollectionUtils.indexOf(listOf("AA", "BBB", "CCCC")) { it.length >= 3 })
53         assertEquals(1, CollectionUtils.indexOf(listOf("AA", null, "CCCC")) { it == null })
54         assertEquals(1, CollectionUtils.indexOf(listOf(null, "CCCC")) { it != null })
55     }
56 
57     @Test
testIndexOfSubArraynull58     fun testIndexOfSubArray() {
59         val haystack = byteArrayOf(1, 2, 3, 4, 5)
60         assertEquals(2, CollectionUtils.indexOfSubArray(haystack, byteArrayOf(3, 4)))
61         assertEquals(3, CollectionUtils.indexOfSubArray(haystack, byteArrayOf(4, 5)))
62         assertEquals(4, CollectionUtils.indexOfSubArray(haystack, byteArrayOf(5)))
63         assertEquals(-1, CollectionUtils.indexOfSubArray(haystack, byteArrayOf(3, 2)))
64         assertEquals(0, CollectionUtils.indexOfSubArray(haystack, byteArrayOf()))
65         assertEquals(-1, CollectionUtils.indexOfSubArray(byteArrayOf(), byteArrayOf(3, 2)))
66         assertEquals(0, CollectionUtils.indexOfSubArray(byteArrayOf(), byteArrayOf()))
67     }
68 
69     @Test
testAllnull70     fun testAll() {
71         assertFalse(CollectionUtils.all(listOf("A", "B", "C", "D", "E")) { it != "E" })
72         assertTrue(CollectionUtils.all(listOf("A", "B", "C", "D", "E")) { it != "F" })
73         assertFalse(CollectionUtils.all(listOf("A", "BB", "CCC")) { it.length > 2 })
74         assertTrue(CollectionUtils.all(listOf("A", "BB", "CCC")) { it.length >= 1 })
75         assertTrue(CollectionUtils.all(listOf("A", "BB", "CCC")) { it.length < 4 })
76         assertTrue(CollectionUtils.all(listOf<String>()) { true })
77         assertTrue(CollectionUtils.all(listOf<String>()) { false })
78         assertTrue(CollectionUtils.all(listOf(1)) { true })
79         assertFalse(CollectionUtils.all(listOf(1)) { false })
80     }
81 
82     @Test
testContainsnull83     fun testContains() {
84         assertTrue(CollectionUtils.contains(shortArrayOf(10, 20, 30), 10))
85         assertTrue(CollectionUtils.contains(shortArrayOf(10, 20, 30), 30))
86         assertFalse(CollectionUtils.contains(shortArrayOf(10, 20, 30), 40))
87         assertFalse(CollectionUtils.contains(null, 10.toShort()))
88         assertTrue(CollectionUtils.contains(intArrayOf(10, 20, 30), 10))
89         assertTrue(CollectionUtils.contains(intArrayOf(10, 20, 30), 30))
90         assertFalse(CollectionUtils.contains(intArrayOf(10, 20, 30), 40))
91         assertFalse(CollectionUtils.contains(null, 10.toInt()))
92         assertTrue(CollectionUtils.contains(arrayOf("A", "B", "C"), "A"))
93         assertTrue(CollectionUtils.contains(arrayOf("A", "B", "C"), "C"))
94         assertFalse(CollectionUtils.contains(arrayOf("A", "B", "C"), "D"))
95         assertFalse(CollectionUtils.contains(null, "A"))
96 
97         val list = listOf("A", "B", "Ab", "C", "D", "E", "A", "E")
98         assertTrue(CollectionUtils.contains(list) { it.length == 2 })
99         assertFalse(CollectionUtils.contains(list) { it.length < 1 })
100         assertTrue(CollectionUtils.contains(list) { it > "A" })
101         assertFalse(CollectionUtils.contains(list) { it > "F" })
102     }
103 
104     @Test
testTotalnull105     fun testTotal() {
106         assertEquals(10, CollectionUtils.total(longArrayOf(3, 6, 1)))
107         assertEquals(10, CollectionUtils.total(longArrayOf(6, 1, 3)))
108         assertEquals(10, CollectionUtils.total(longArrayOf(1, 3, 6)))
109         assertEquals(3, CollectionUtils.total(longArrayOf(1, 1, 1)))
110         assertEquals(0, CollectionUtils.total(null))
111     }
112 
113     @Test
testFindFirstFindLastnull114     fun testFindFirstFindLast() {
115         val listAE = listOf("A", "B", "C", "D", "E")
116         assertSame(CollectionUtils.findFirst(listAE) { it == "A" }, listAE[0])
117         assertSame(CollectionUtils.findFirst(listAE) { it == "B" }, listAE[1])
118         assertSame(CollectionUtils.findFirst(listAE) { it == "E" }, listAE[4])
119         assertNull(CollectionUtils.findFirst(listAE) { it == "F" })
120         assertSame(CollectionUtils.findLast(listAE) { it == "A" }, listAE[0])
121         assertSame(CollectionUtils.findLast(listAE) { it == "B" }, listAE[1])
122         assertSame(CollectionUtils.findLast(listAE) { it == "E" }, listAE[4])
123         assertNull(CollectionUtils.findLast(listAE) { it == "F" })
124 
125         val listMulti = listOf("A", "B", "A", "C", "D", "E", "A", "E")
126         assertSame(CollectionUtils.findFirst(listMulti) { it == "A" }, listMulti[0])
127         assertSame(CollectionUtils.findFirst(listMulti) { it == "B" }, listMulti[1])
128         assertSame(CollectionUtils.findFirst(listMulti) { it == "E" }, listMulti[5])
129         assertNull(CollectionUtils.findFirst(listMulti) { it == "F" })
130         assertSame(CollectionUtils.findLast(listMulti) { it == "A" }, listMulti[6])
131         assertSame(CollectionUtils.findLast(listMulti) { it == "B" }, listMulti[1])
132         assertSame(CollectionUtils.findLast(listMulti) { it == "E" }, listMulti[7])
133         assertNull(CollectionUtils.findLast(listMulti) { it == "F" })
134     }
135 
136     @Test
testMapnull137     fun testMap() {
138         val listAE = listOf("A", "B", "C", "D", "E", null)
139         assertEquals(listAE.map { "-$it-" }, CollectionUtils.map(listAE) { "-$it-" })
140     }
141 
142     @Test
testZipnull143     fun testZip() {
144         val listAE = listOf("A", "B", "C", "D", "E")
145         val list15 = listOf(1, 2, 3, 4, 5)
146         // Normal #zip returns kotlin.Pair, not android.util.Pair
147         assertEquals(list15.zip(listAE).map { android.util.Pair(it.first, it.second) },
148                 CollectionUtils.zip(list15, listAE))
149         val listNull = listOf("A", null, "B", "C", "D")
150         assertEquals(list15.zip(listNull).map { android.util.Pair(it.first, it.second) },
151                 CollectionUtils.zip(list15, listNull))
152         assertEquals(emptyList<android.util.Pair<Int, Int>>(),
153                 CollectionUtils.zip(emptyList<Int>(), emptyList<Int>()))
154         assertFailsWith<IllegalArgumentException> {
155             // Different size
156             CollectionUtils.zip(listOf(1, 2), list15)
157         }
158     }
159 
160     @Test
testAssocnull161     fun testAssoc() {
162         val listADA = listOf("A", "B", "C", "D", "A")
163         val list15 = listOf(1, 2, 3, 4, 5)
164         assertEquals(list15.zip(listADA).toMap(), CollectionUtils.assoc(list15, listADA))
165 
166         // Null key is fine
167         val assoc = CollectionUtils.assoc(listOf(1, 2, null), listOf("A", "B", "C"))
168         assertEquals("C", assoc[null])
169 
170         assertFailsWith<IllegalArgumentException> {
171             // Same key multiple times
172             CollectionUtils.assoc(listOf("A", "B", "A"), listOf(1, 2, 3))
173         }
174         assertFailsWith<IllegalArgumentException> {
175             // Same key multiple times, but it's null
176             CollectionUtils.assoc(listOf(null, "B", null), listOf(1, 2, 3))
177         }
178         assertFailsWith<IllegalArgumentException> {
179             // Different size
180             CollectionUtils.assoc(listOf(1, 2), list15)
181         }
182     }
183 
184     @Test
testGetIndexForValuenull185     fun testGetIndexForValue() {
186         val sparseArray = SparseArray<String>()
187         sparseArray.put(5, "hello")
188         sparseArray.put(10, "abcd")
189         sparseArray.put(20, null)
190 
191         val value1 = "abcd"
192         val value1Copy = String(value1.toCharArray())
193         val value2 = null
194 
195         assertEquals(1, CollectionUtils.getIndexForValue(sparseArray, value1))
196         assertEquals(1, CollectionUtils.getIndexForValue(sparseArray, value1Copy))
197         assertEquals(2, CollectionUtils.getIndexForValue(sparseArray, value2))
198     }
199 }
200