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.filters.SmallTest;
31import android.support.test.runner.AndroidJUnit4;
32import android.support.v7.preference.PreferenceManager;
33import android.support.v7.preference.PreferenceScreen;
34import android.support.v7.preference.tests.helpers.PreferenceWrapper;
35
36import org.junit.Before;
37import org.junit.Test;
38import org.junit.runner.RunWith;
39
40import java.util.Arrays;
41import java.util.Collections;
42import java.util.HashSet;
43import java.util.Set;
44
45/**
46 * Tests for {@link android.support.v7.preference.Preference} persist / retrieve logic.
47 */
48@SmallTest
49@RunWith(AndroidJUnit4.class)
50public 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