1 /* 2 * Copyright (C) 2008 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 android.util.cts; 18 19 import static org.junit.Assert.assertEquals; 20 import static org.junit.Assert.assertFalse; 21 22 import android.support.test.filters.SmallTest; 23 import android.support.test.runner.AndroidJUnit4; 24 import android.util.SparseIntArray; 25 26 import org.junit.Test; 27 import org.junit.runner.RunWith; 28 29 @SmallTest 30 @RunWith(AndroidJUnit4.class) 31 public class SparseIntArrayTest { 32 private static final int[] KEYS = {12, 23, 4, 6, 8, 1, 3, -12, 0, -3, 11, 14, -23}; 33 private static final int[] VALUES = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; 34 private static final int NON_EXISTED_KEY = 123; 35 private static final int VALUE_FOR_NON_EXISTED_KEY = -1; 36 37 @Test 38 public void testSparseIntArrayWithDefaultCapacity() { 39 SparseIntArray sparseIntArray = new SparseIntArray(); 40 assertEquals(0, sparseIntArray.size()); 41 42 int length = VALUES.length; 43 for (int i = 0; i < length; i++) { 44 sparseIntArray.put(KEYS[i], VALUES[i]); 45 assertEquals(i + 1, sparseIntArray.size()); 46 } 47 for (int i = 0; i < length; i++) { 48 assertEquals(VALUES[i], sparseIntArray.get(KEYS[i])); 49 } 50 for (int i = 0; i < length; i++) { 51 assertEquals(sparseIntArray.indexOfValue(VALUES[i]), 52 sparseIntArray.indexOfKey(KEYS[i])); 53 } 54 55 // for key already exist, old value will be replaced 56 int existKey = KEYS[0]; 57 int oldValue = VALUES[0]; // 0 58 int newValue = 23; 59 assertEquals(oldValue, sparseIntArray.get(existKey)); 60 assertEquals(13, sparseIntArray.size()); 61 sparseIntArray.put(existKey, newValue); 62 assertEquals(newValue, sparseIntArray.get(existKey)); 63 assertEquals(13, sparseIntArray.size()); 64 65 assertEquals(VALUE_FOR_NON_EXISTED_KEY, 66 sparseIntArray.get(NON_EXISTED_KEY, VALUE_FOR_NON_EXISTED_KEY)); 67 assertEquals(0, sparseIntArray.get(NON_EXISTED_KEY)); // the default value is 0 68 69 int size = sparseIntArray.size(); 70 sparseIntArray.append(NON_EXISTED_KEY, VALUE_FOR_NON_EXISTED_KEY); 71 assertEquals(size + 1, sparseIntArray.size()); 72 assertEquals(size, sparseIntArray.indexOfKey(NON_EXISTED_KEY)); 73 assertEquals(size, sparseIntArray.indexOfValue(VALUE_FOR_NON_EXISTED_KEY)); 74 assertEquals(NON_EXISTED_KEY, sparseIntArray.keyAt(size)); 75 assertEquals(VALUE_FOR_NON_EXISTED_KEY, sparseIntArray.valueAt(size)); 76 77 assertEquals(VALUES[1], sparseIntArray.get(KEYS[1])); 78 assertFalse(VALUE_FOR_NON_EXISTED_KEY == VALUES[1]); 79 sparseIntArray.delete(KEYS[1]); 80 assertEquals(VALUE_FOR_NON_EXISTED_KEY, 81 sparseIntArray.get(KEYS[1], VALUE_FOR_NON_EXISTED_KEY)); 82 83 sparseIntArray.clear(); 84 assertEquals(0, sparseIntArray.size()); 85 } 86 87 @Test 88 public void testSparseIntArrayWithSpecifiedCapacity() { 89 SparseIntArray sparseIntArray = new SparseIntArray(5); 90 assertEquals(0, sparseIntArray.size()); 91 92 int length = VALUES.length; 93 for (int i = 0; i < length; i++) { 94 sparseIntArray.put(KEYS[i], VALUES[i]); 95 assertEquals(i + 1, sparseIntArray.size()); 96 } 97 for (int i = 0; i < length; i++) { 98 assertEquals(VALUES[i], sparseIntArray.get(KEYS[i])); 99 } 100 for (int i = 0; i < length; i++) { 101 assertEquals(sparseIntArray.indexOfValue(VALUES[i]), sparseIntArray.indexOfKey(KEYS[i])); 102 } 103 104 // for key already exist, old value will be replaced 105 int existKey = KEYS[0]; 106 int oldValue = VALUES[0]; // 0 107 int newValue = 23; 108 assertEquals(oldValue, sparseIntArray.get(existKey)); 109 assertEquals(13, sparseIntArray.size()); 110 sparseIntArray.put(existKey, newValue); 111 assertEquals(newValue, sparseIntArray.get(existKey)); 112 assertEquals(13, sparseIntArray.size()); 113 114 assertEquals(VALUE_FOR_NON_EXISTED_KEY, 115 sparseIntArray.get(NON_EXISTED_KEY, VALUE_FOR_NON_EXISTED_KEY)); 116 assertEquals(0, sparseIntArray.get(NON_EXISTED_KEY)); // the default value is 0 117 118 int size = sparseIntArray.size(); 119 sparseIntArray.append(NON_EXISTED_KEY, VALUE_FOR_NON_EXISTED_KEY); 120 assertEquals(size + 1, sparseIntArray.size()); 121 assertEquals(size, sparseIntArray.indexOfKey(NON_EXISTED_KEY)); 122 assertEquals(size, sparseIntArray.indexOfValue(VALUE_FOR_NON_EXISTED_KEY)); 123 assertEquals(NON_EXISTED_KEY, sparseIntArray.keyAt(size)); 124 assertEquals(VALUE_FOR_NON_EXISTED_KEY, sparseIntArray.valueAt(size)); 125 126 assertEquals(VALUES[1], sparseIntArray.get(KEYS[1])); 127 assertFalse(VALUE_FOR_NON_EXISTED_KEY == VALUES[1]); 128 sparseIntArray.delete(KEYS[1]); 129 assertEquals(VALUE_FOR_NON_EXISTED_KEY, 130 sparseIntArray.get(KEYS[1], VALUE_FOR_NON_EXISTED_KEY)); 131 132 sparseIntArray.clear(); 133 assertEquals(0, sparseIntArray.size()); 134 } 135 136 @Test 137 public void testSparseIntArrayRemoveAt() { 138 final int[] testData = { 139 13, 42, 85932, 885932, -6, Integer.MAX_VALUE, 0, Integer.MIN_VALUE }; 140 141 // test removal of one key/value pair, varying the index 142 for (int i = 0; i < testData.length; i++) { 143 SparseIntArray sia = new SparseIntArray(); 144 for (int value : testData) { 145 sia.put(value, value); 146 } 147 int size = testData.length; 148 assertEquals(size, sia.size()); 149 int key = sia.keyAt(i); 150 assertEquals(key, sia.get(key)); 151 sia.removeAt(i); 152 assertEquals(21, sia.get(key, 21)); 153 assertEquals(size-1, sia.size()); 154 } 155 156 // remove the 0th pair repeatedly until the array is empty 157 SparseIntArray sia = new SparseIntArray(); 158 for (int value : testData) { 159 sia.put(value, value); 160 } 161 for (int i = 0; i < testData.length; i++) { 162 sia.removeAt(0); 163 } 164 assertEquals(0, sia.size()); 165 // make sure all pairs have been removed 166 for (int value : testData) { 167 assertEquals(21, sia.get(value, 21)); 168 } 169 170 // test removal of a pair from an empty array 171 try { 172 new SparseIntArray().removeAt(0); 173 } catch (ArrayIndexOutOfBoundsException ignored) { 174 // expected 175 } 176 } 177 178 @Test 179 public void testIterationOrder() { 180 SparseIntArray sparseArray = new SparseIntArray(); 181 // No matter in which order they are inserted. 182 sparseArray.put(1, 2); 183 sparseArray.put(10, 20); 184 sparseArray.put(5, 40); 185 sparseArray.put(Integer.MAX_VALUE, Integer.MIN_VALUE); 186 // The keys are returned in order. 187 assertEquals(1, sparseArray.keyAt(0)); 188 assertEquals(5, sparseArray.keyAt(1)); 189 assertEquals(10, sparseArray.keyAt(2)); 190 assertEquals(Integer.MAX_VALUE, sparseArray.keyAt(3)); 191 // The values are returned in the order of the corresponding keys. 192 assertEquals(2, sparseArray.valueAt(0)); 193 assertEquals(40, sparseArray.valueAt(1)); 194 assertEquals(20, sparseArray.valueAt(2)); 195 assertEquals(Integer.MIN_VALUE, sparseArray.valueAt(3)); 196 } 197 198 } 199 200
