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.ThreadUtils;
  13 import org.chromium.base.test.util.Feature;
  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         @Override
 172         public void onChangeFontSize(float font) {
 173             mFontSize = font;
 174         }
 175
 176         public boolean getForceEnableZoom() {
 177             return mForceEnableZoom;
 178         }
 179
 180         @Override
 181         public void onChangeForceEnableZoom(boolean enabled) {
 182             mForceEnableZoom = enabled;
 183         }
 184
 185         @Override
 186         public void onChangeUserSetForceEnableZoom(boolean enabled) {
 187             mUserSetForceEnableZoom = enabled;
 188         }
 189
 190         public boolean getUserSetForceEnableZoom() {
 191             return mUserSetForceEnableZoom;
 192         }
 193     }
 194
 195     private void getFontSizePrefs(final Context context) {
 196         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
 197             @Override
 198             public void run() {
 199                 mFontSizePrefs = FontSizePrefs.getInstance(context);
 200             }
 201         });
 202     }
 203
 204     private void setFontScale(final float fontsize) {
 205         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
 206             @Override
 207             public void run() {
 208                 mFontSizePrefs.setFontScaleFactor(fontsize);
 209             }
 210         });
 211     }
 212
 213     private float getFontScale() {
 214         return ThreadUtils.runOnUiThreadBlockingNoException(new Callable<Float>() {
 215             @Override
 216             public Float call() {
 217                 return mFontSizePrefs.getFontScaleFactor();
 218             }
 219         });
 220     }
 221
 222     private void setForceEnableZoom(final boolean enabled) {
 223         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
 224             @Override
 225             public void run() {
 226                 mFontSizePrefs.setForceEnableZoom(enabled);
 227             }
 228         });
 229     }
 230
 231     private boolean getForceEnableZoom() {
 232         return ThreadUtils.runOnUiThreadBlockingNoException(new Callable<Boolean>() {
 233             @Override
 234             public Boolean call() {
 235                 return mFontSizePrefs.getForceEnableZoom();
 236             }
 237         });
 238     }
 239
 240     private void setUserSetForceEnableZoom(final boolean enabled) {
 241         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
 242             @Override
 243             public void run() {
 244                 mFontSizePrefs.setUserSetForceEnableZoom(enabled);
 245             }
 246         });
 247     }
 248 }