src/chrome/android/javatests/src/org/chromium/chrome/browser/accessibility/FontSizePrefsTest.java

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 package org.chromium.chrome.browser.accessibility;
   6
   7 import android.content.Context;
   8 import android.content.SharedPreferences;
   9 import android.preference.PreferenceManager;
  10 import android.test.suitebuilder.annotation.SmallTest;
  11
  12 import org.chromium.base.test.util.Feature;
  13 import org.chromium.base.ThreadUtils;
  14 import org.chromium.chrome.shell.ChromeShellTestBase;
  15 import org.chromium.content.browser.test.util.UiUtils;
  16
  17 import java.util.concurrent.Callable;
  18
  19 /**
  20  * Test class for {@link FontSizePrefs}.
  21  */
  22 public class FontSizePrefsTest extends ChromeShellTestBase {
  23
  24     private FontSizePrefs mFontSizePrefs;
  25     private SharedPreferences.Editor mSharedPreferencesEditor;
  26
  27     @Override
  28     public void setUp() throws Exception {
  29         super.setUp();
  30         Context context = getInstrumentation().getTargetContext();
  31         startChromeBrowserProcessSync(context);
  32         getFontSizePrefs(context);
  33         mSharedPreferencesEditor = PreferenceManager.getDefaultSharedPreferences(context).edit();
  34     }
  35
  36     @Override
  37     protected void tearDown() throws Exception {
  38         mSharedPreferencesEditor.remove(FontSizePrefs.PREF_USER_SET_FORCE_ENABLE_ZOOM).commit();
  39         super.tearDown();
  40     }
  41
  42     @SmallTest
  43     @Feature({"Accessibility"})
  44     public void testGetAndSetFontAndForceEnableZoom() throws InterruptedException {
  45         // Check default font.
  46         assertEquals(1f, getFontScale());
  47         // Check that setting the value of font scale factor works.
  48         float newTextScale = 1.2f;
  49         setFontScale(newTextScale);
  50         assertEquals(newTextScale, getFontScale());
  51
  52         // Check the default value of force enable zoom.
  53         assertFalse(getForceEnableZoom());
  54         // Check that setting the value of force enable zoom works.
  55         setForceEnableZoom(true);
  56         assertTrue(getForceEnableZoom());
  57     }
  58
  59     @SmallTest
  60     @Feature({"Accessibility"})
  61     public void testGetAndSetUserSetForceEnableZoom() throws InterruptedException {
  62         // Check the default value of user set force enable zoom.
  63         assertFalse(mFontSizePrefs.getUserSetForceEnableZoom());
  64         // Check that setting the value of user set force enable zoom works.
  65         setUserSetForceEnableZoom(true);
  66         assertTrue(mFontSizePrefs.getUserSetForceEnableZoom());
  67     }
  68
  69     @SmallTest
  70     @Feature({"Accessibility"})
  71     public void testObserversForceEnableZoom() throws InterruptedException {
  72         TestingObserver test1 = new TestingObserver();
  73         TestingObserver test2 = new TestingObserver();
  74         mFontSizePrefs.addObserver(test1);
  75         mFontSizePrefs.addObserver(test2);
  76
  77         // Checks that force enable zoom for both observers is correctly changed.
  78         setForceEnableZoom(true);
  79         UiUtils.settleDownUI(getInstrumentation());
  80         assertTrue(test1.getForceEnableZoom());
  81         assertTrue(test2.getForceEnableZoom());
  82
  83         // Checks that removing observer and setting force enable zoom works.
  84         mFontSizePrefs.removeObserver(test1);
  85         setForceEnableZoom(false);
  86         UiUtils.settleDownUI(getInstrumentation());
  87         assertTrue(test1.getForceEnableZoom());
  88         assertFalse(test2.getForceEnableZoom());
  89         mFontSizePrefs.removeObserver(test2);
  90     }
  91
  92     @SmallTest
  93     @Feature({"Accessibility"})
  94     public void testObserversFontScale() throws InterruptedException {
  95         TestingObserver test1 = new TestingObserver();
  96         TestingObserver test2 = new TestingObserver();
  97         mFontSizePrefs.addObserver(test1);
  98         mFontSizePrefs.addObserver(test2);
  99
 100         // Checks that font scale for both observers is correctly changed.
 101         float newTextScale = 1.2f;
 102         setFontScale(newTextScale);
 103         UiUtils.settleDownUI(getInstrumentation());
 104         assertEquals(newTextScale, test1.getFontScaleFactor());
 105         assertEquals(newTextScale, test2.getFontScaleFactor());
 106
 107         // Checks that removing observer and setting font works.
 108         float newerTextScale = 1.4f;
 109         mFontSizePrefs.removeObserver(test1);
 110         setFontScale(newerTextScale);
 111         UiUtils.settleDownUI(getInstrumentation());
 112         assertEquals(newTextScale, test1.getFontScaleFactor());
 113         assertEquals(newerTextScale, test2.getFontScaleFactor());
 114         mFontSizePrefs.removeObserver(test2);
 115     }
 116
 117     @SmallTest
 118     @Feature({"Accessibility"})
 119     public void testObserversUserSetForceEnableZoom() throws InterruptedException {
 120         TestingObserver test1 = new TestingObserver();
 121         TestingObserver test2 = new TestingObserver();
 122         mFontSizePrefs.addObserver(test1);
 123         mFontSizePrefs.addObserver(test2);
 124
 125         // Checks that force enable zoom for both observers is correctly changed.
 126         setUserSetForceEnableZoom(true);
 127         UiUtils.settleDownUI(getInstrumentation());
 128         assertTrue(test1.getUserSetForceEnableZoom());
 129         assertTrue(test2.getUserSetForceEnableZoom());
 130
 131         // Checks that removing observer and setting force enable zoom works.
 132         mFontSizePrefs.removeObserver(test1);
 133         setUserSetForceEnableZoom(false);
 134         UiUtils.settleDownUI(getInstrumentation());
 135         assertTrue(test1.getUserSetForceEnableZoom());
 136         assertFalse(test2.getUserSetForceEnableZoom());
 137         mFontSizePrefs.removeObserver(test2);
 138     }
 139
 140     @SmallTest
 141     @Feature({"Accessibility"})
 142     public void testMultipleAddMultipleDeleteObservers() throws InterruptedException {
 143         TestingObserver test = new TestingObserver();
 144
 145         // Should successfully add the observer the first time.
 146         assertTrue(mFontSizePrefs.addObserver(test));
 147         // Observer cannot be added again, should return false.
 148         assertFalse(mFontSizePrefs.addObserver(test));
 149
 150         // Delete the observer the first time.
 151         assertTrue(mFontSizePrefs.removeObserver(test));
 152         // Observer cannot be deleted again, should return false.
 153         assertFalse(mFontSizePrefs.removeObserver(test));
 154     }
 155
 156     private static class TestingObserver implements FontSizePrefs.Observer {
 157         private float mFontSize;
 158         private boolean mForceEnableZoom;
 159         private boolean mUserSetForceEnableZoom;
 160
 161         public TestingObserver() {
 162             mFontSize = 1;
 163             mForceEnableZoom = false;
 164             mUserSetForceEnableZoom = false;
 165         }
 166
 167         public float getFontScaleFactor() {
 168             return mFontSize;
 169         }
 170
 171         public void onChangeFontSize(float font) {
 172             mFontSize = font;
 173         }
 174
 175         public boolean getForceEnableZoom() {
 176             return mForceEnableZoom;
 177         }
 178
 179         public void onChangeForceEnableZoom(boolean enabled) {
 180             mForceEnableZoom = enabled;
 181         }
 182
 183         public void onChangeUserSetForceEnableZoom(boolean enabled) {
 184             mUserSetForceEnableZoom = enabled;
 185         }
 186
 187         public boolean getUserSetForceEnableZoom() {
 188             return mUserSetForceEnableZoom;
 189         }
 190     }
 191
 192     private void getFontSizePrefs(final Context context) {
 193         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
 194             public void run() {
 195                 mFontSizePrefs = FontSizePrefs.getInstance(context);
 196             }
 197         });
 198     }
 199
 200     private void setFontScale(final float fontsize) {
 201         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
 202             public void run() {
 203                 mFontSizePrefs.setFontScaleFactor(fontsize);
 204             }
 205         });
 206     }
 207
 208     private float getFontScale() {
 209         return ThreadUtils.runOnUiThreadBlockingNoException(new Callable<Float>() {
 210             @Override
 211             public Float call() {
 212                 return mFontSizePrefs.getFontScaleFactor();
 213             }
 214         });
 215     }
 216
 217     private void setForceEnableZoom(final boolean enabled) {
 218         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
 219             public void run() {
 220                 mFontSizePrefs.setForceEnableZoom(enabled);
 221             }
 222         });
 223     }
 224
 225     private boolean getForceEnableZoom() {
 226         return ThreadUtils.runOnUiThreadBlockingNoException(new Callable<Boolean>() {
 227             @Override
 228             public Boolean call() {
 229                 return mFontSizePrefs.getForceEnableZoom();
 230             }
 231         });
 232     }
 233
 234     private void setUserSetForceEnableZoom(final boolean enabled) {
 235         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
 236             public void run() {
 237                 mFontSizePrefs.setUserSetForceEnableZoom(enabled);
 238             }
 239         });
 240     }
 241 }