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