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 android.support.v7.preference.tests; 18 19 import static org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder; 20 import static org.junit.Assert.assertEquals; 21 import static org.junit.Assert.assertFalse; 22 import static org.junit.Assert.assertNull; 23 import static org.junit.Assert.assertThat; 24 import static org.junit.Assert.assertTrue; 25 26 import android.content.Context; 27 import android.content.SharedPreferences; 28 import android.support.test.InstrumentationRegistry; 29 import android.support.test.annotation.UiThreadTest; 30 import android.support.test.filters.SmallTest; 31 import android.support.test.runner.AndroidJUnit4; 32 import android.support.v7.preference.PreferenceManager; 33 import android.support.v7.preference.PreferenceScreen; 34 import android.support.v7.preference.tests.helpers.PreferenceWrapper; 35 36 import org.junit.Before; 37 import org.junit.Test; 38 import org.junit.runner.RunWith; 39 40 import java.util.Arrays; 41 import java.util.Collections; 42 import java.util.HashSet; 43 import java.util.Set; 44 45 /** 46 * Tests for {@link android.support.v7.preference.Preference} persist / retrieve logic. 47 */ 48 @SmallTest 49 @RunWith(AndroidJUnit4.class) 50 public class PreferencePersistTest { 51 52 private static final String KEY = "TestPrefKey"; 53 54 private static final float FLOAT_PRECISION = 0.01f; 55 56 private static final String[] A_B = {"a", "b"}; 57 private static final String[] C_D = {"c", "d"}; 58 private static final Set<String> TEST_STR_SET = new HashSet<>(Arrays.asList(A_B)); 59 private static final Set<String> TEST_STR_SET2 = new HashSet<>(Arrays.asList(C_D)); 60 private static final Set<String> TEST_DEFAULT_STR_SET = Collections.singleton("e"); 61 62 private PreferenceWrapper mPreference; 63 private SharedPreferences mSharedPref; 64 65 @Before 66 @UiThreadTest 67 public void setup() { 68 Context context = InstrumentationRegistry.getTargetContext(); 69 PreferenceManager manager = new PreferenceManager(context); 70 mSharedPref = manager.getSharedPreferences(); 71 72 mPreference = new PreferenceWrapper(context); 73 mPreference.setKey(KEY); 74 75 PreferenceScreen screen = manager.createPreferenceScreen(context); 76 screen.addPreference(mPreference); 77 78 // Make sure that the key is not present in SharedPreferences to ensure tests 79 // correctness. 80 mSharedPref.edit().remove(KEY).apply(); 81 assertNull(mSharedPref.getString(KEY, null)); 82 } 83 84 @Test 85 @UiThreadTest 86 public void string_retrieveWhenEmpty_returnsDefault() { 87 final String expected = "Default"; 88 89 String result = mPreference.getString(expected); 90 91 assertEquals(expected, result); 92 } 93 94 @Test 95 @UiThreadTest 96 public void string_persist_getsStoredToSharedPrefs() { 97 final String expected = "Test"; 98 99 boolean wasPersisted = mPreference.putString(expected); 100 101 assertTrue(wasPersisted); 102 assertEquals(expected, mSharedPref.getString(KEY, null)); 103 } 104 105 @Test 106 @UiThreadTest 107 public void string_persistWhileDisabled_notPersisted() { 108 mPreference.setPersistent(false); 109 110 boolean wasPersisted = mPreference.putString("Test"); 111 112 assertFalse(wasPersisted); 113 assertNull(mSharedPref.getString(KEY, null)); 114 } 115 116 @Test 117 @UiThreadTest 118 public void string_persistAndRetrieve_returnsPersistedValue() { 119 final String expected = "Test"; 120 121 mPreference.putString(expected); 122 String result = mPreference.getString("Default"); 123 124 assertEquals(expected, result); 125 } 126 127 @Test 128 @UiThreadTest 129 public void string_persistTwiceAndRetrieve_returnsSecondValue() { 130 final String expected = "Second"; 131 132 mPreference.putString("First"); 133 mPreference.putString(expected); 134 String result = mPreference.getString("Default"); 135 136 assertEquals(expected, result); 137 } 138 139 140 @Test 141 @UiThreadTest 142 public void stringSet_retrieveWhenEmpty_returnsDefault() { 143 final Set<String> expected = TEST_DEFAULT_STR_SET; 144 145 Set<String> result = mPreference.getStringSet(expected); 146 147 assertThat(result, containsInAnyOrder(expected.toArray())); 148 } 149 150 @Test 151 @UiThreadTest 152 public void stringSet_persist_getsStoredToSharedPrefs() { 153 boolean wasPersisted = mPreference.putStringSet(TEST_DEFAULT_STR_SET); 154 155 assertTrue(wasPersisted); 156 assertThat(mSharedPref.getStringSet(KEY, null), 157 containsInAnyOrder(TEST_DEFAULT_STR_SET.toArray())); 158 } 159 160 @Test 161 @UiThreadTest 162 public void stringSet_persistWhileDisabled_notPersisted() { 163 mPreference.setPersistent(false); 164 165 boolean wasPersisted = mPreference.putStringSet(TEST_STR_SET); 166 167 assertFalse(wasPersisted); 168 assertNull(mSharedPref.getString(KEY, null)); 169 } 170 171 @Test 172 @UiThreadTest 173 public void stringSet_persistAndRetrieve_returnsPersistedValue() { 174 final Set<String> expected = TEST_STR_SET; 175 176 mPreference.putStringSet(expected); 177 Set<String> result = mPreference.getStringSet(TEST_DEFAULT_STR_SET); 178 179 assertThat(result, containsInAnyOrder(expected.toArray())); 180 } 181 182 @Test 183 @UiThreadTest 184 public void stringSet_persistTwiceAndRetrieve_returnsSecondValue() { 185 final Set<String> expected = TEST_STR_SET2; 186 187 mPreference.putStringSet(TEST_STR_SET); 188 mPreference.putStringSet(expected); 189 Set<String> result = mPreference.getStringSet(TEST_DEFAULT_STR_SET); 190 191 assertThat(result, containsInAnyOrder(expected.toArray())); 192 } 193 194 195 @Test 196 @UiThreadTest 197 public void int_retrieveWhenEmpty_returnsDefault() { 198 final int expected = 1; 199 int result = mPreference.getInt(expected); 200 201 assertEquals(expected, result); 202 } 203 204 @Test 205 @UiThreadTest 206 public void int_persist_getsStoredToSharedPrefs() { 207 final int expected = 1; 208 209 boolean wasPersisted = mPreference.putInt(expected); 210 211 assertTrue(wasPersisted); 212 assertEquals(expected, mSharedPref.getInt(KEY, -1)); 213 } 214 215 @Test 216 @UiThreadTest 217 public void int_persistWhileDisabled_notPersisted() { 218 mPreference.setPersistent(false); 219 220 boolean wasPersisted = mPreference.putInt(1); 221 222 assertFalse(wasPersisted); 223 assertEquals(-1, mSharedPref.getLong(KEY, -1)); 224 } 225 226 @Test 227 @UiThreadTest 228 public void int_persistAndRetrieve_returnsPersistedValue() { 229 final int expected = 1; 230 231 mPreference.putInt(expected); 232 int result = mPreference.getInt(-1); 233 234 assertEquals(expected, result); 235 } 236 237 @Test 238 @UiThreadTest 239 public void int_persistTwiceAndRetrieve_returnsSecondValue() { 240 final int expected = 2; 241 242 mPreference.putInt(1); 243 mPreference.putInt(expected); 244 int result = mPreference.getInt(-1); 245 246 assertEquals(expected, result); 247 } 248 249 250 @Test 251 @UiThreadTest 252 public void long_retrieveWhenEmpty_returnsDefault() { 253 assertEquals(1, mPreference.getLong(1)); 254 } 255 256 @Test 257 @UiThreadTest 258 public void long_persist_getsStoredToSharedPrefs() { 259 final long expected = 1; 260 261 boolean wasPersisted = mPreference.putLong(expected); 262 263 assertTrue(wasPersisted); 264 assertEquals(expected, mSharedPref.getLong(KEY, -1)); 265 } 266 267 @Test 268 @UiThreadTest 269 public void long_persistWhileDisabled_notPersisted() { 270 mPreference.setPersistent(false); 271 272 boolean wasPersisted = mPreference.putLong(1); 273 274 assertFalse(wasPersisted); 275 assertEquals(-1, mSharedPref.getLong(KEY, -1)); 276 } 277 278 @Test 279 @UiThreadTest 280 public void long_persistAndRetrieve_returnsPersistedValue() { 281 final long expected = 1; 282 283 mPreference.putLong(expected); 284 long result = mPreference.getLong(-1); 285 286 assertEquals(expected, result); 287 } 288 289 @Test 290 @UiThreadTest 291 public void long_persistTwiceAndRetrieve_returnsSecondValue() { 292 final long expected = 2; 293 294 mPreference.putLong(1); 295 mPreference.putLong(expected); 296 long result = mPreference.getLong(-1); 297 298 assertEquals(expected, result); 299 } 300 301 302 @Test 303 @UiThreadTest 304 public void float_retrieveWhenEmpty_returnsDefault() { 305 assertEquals(1, mPreference.getFloat(1), FLOAT_PRECISION); 306 } 307 308 @Test 309 @UiThreadTest 310 public void float_persist_getsStoredToSharedPrefs() { 311 final float expected = 1; 312 313 boolean wasPersisted = mPreference.putFloat(expected); 314 315 assertTrue(wasPersisted); 316 assertEquals(expected, mSharedPref.getFloat(KEY, -1), FLOAT_PRECISION); 317 } 318 319 @Test 320 @UiThreadTest 321 public void float_persistWhileDisabled_notPersisted() { 322 mPreference.setPersistent(false); 323 324 boolean wasPersisted = mPreference.putFloat(1); 325 326 assertFalse(wasPersisted); 327 assertEquals(-1, mSharedPref.getFloat(KEY, -1), FLOAT_PRECISION); 328 } 329 330 @Test 331 @UiThreadTest 332 public void float_persistAndRetrieve_returnsPersistedValue() { 333 final float expected = 1; 334 335 mPreference.putFloat(expected); 336 float result = mPreference.getFloat(-1); 337 338 assertEquals(expected, result, FLOAT_PRECISION); 339 } 340 341 @Test 342 @UiThreadTest 343 public void float_persistTwiceAndRetrieve_returnsSecondValue() { 344 final float expected = 2; 345 346 mPreference.putFloat(1); 347 mPreference.putFloat(expected); 348 float result = mPreference.getFloat(-1); 349 350 assertEquals(expected, result, FLOAT_PRECISION); 351 } 352 353 354 @Test 355 @UiThreadTest 356 public void boolean_retrieveWhenEmpty_returnsDefault() { 357 final boolean expected = true; 358 359 boolean result = mPreference.getBoolean(expected); 360 361 assertEquals(expected, result); 362 } 363 364 @Test 365 @UiThreadTest 366 public void boolean_persist_getsStoredToSharedPrefs() { 367 final boolean expected = true; 368 369 boolean wasPersisted = mPreference.putBoolean(expected); 370 371 assertTrue(wasPersisted); 372 assertEquals(expected, mSharedPref.getBoolean(KEY, !expected)); 373 } 374 375 @Test 376 @UiThreadTest 377 public void boolean_persistWhileDisabled_notPersisted() { 378 mPreference.setPersistent(false); 379 380 boolean wasPersisted = mPreference.putBoolean(true); 381 382 assertFalse(wasPersisted); 383 assertEquals(false, mSharedPref.getBoolean(KEY, false)); 384 } 385 386 @Test 387 @UiThreadTest 388 public void boolean_persistAndRetrieve_returnsPersistedValue() { 389 final boolean expected = true; 390 391 mPreference.putBoolean(expected); 392 boolean result = mPreference.getBoolean(!expected); 393 394 assertEquals(expected, result); 395 } 396 397 @Test 398 @UiThreadTest 399 public void boolean_persistTwiceAndRetrieve_returnsSecondValue() { 400 final boolean expected = false; 401 402 mPreference.putBoolean(!expected); 403 mPreference.putBoolean(expected); 404 boolean result = mPreference.getBoolean(!expected); 405 406 assertEquals(expected, result); 407 } 408 409 } 410
