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