KeyboardThemeTests.java revision 8f3e778a21ff2c8855fb0014116eda9eec7f2b5d
1/* 2 * Copyright (C) 2014 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 com.android.inputmethod.keyboard; 18 19import static com.android.inputmethod.keyboard.KeyboardTheme.THEME_ID_ICS; 20import static com.android.inputmethod.keyboard.KeyboardTheme.THEME_ID_KLP; 21import static com.android.inputmethod.keyboard.KeyboardTheme.THEME_ID_LXX_DARK; 22import static com.android.inputmethod.keyboard.KeyboardTheme.THEME_ID_LXX_LIGHT; 23 24import android.content.SharedPreferences; 25import android.os.Build.VERSION_CODES; 26import android.preference.PreferenceManager; 27import android.test.AndroidTestCase; 28import android.test.suitebuilder.annotation.SmallTest; 29 30@SmallTest 31public class KeyboardThemeTests extends AndroidTestCase { 32 private SharedPreferences mPrefs; 33 34 // TODO: Remove this constant once the *next* version becomes available. 35 private static final int VERSION_CODES_LXX = VERSION_CODES.CUR_DEVELOPMENT; 36 37 private static final int THEME_ID_NULL = -1; 38 private static final int THEME_ID_UNKNOWN = -2; 39 private static final int THEME_ID_ILLEGAL = -3; 40 private static final String ILLEGAL_THEME_ID_STRING = "ThisCausesNumberFormatExecption"; 41 42 @Override 43 protected void setUp() throws Exception { 44 super.setUp(); 45 mPrefs = PreferenceManager.getDefaultSharedPreferences(getContext()); 46 } 47 48 /* 49 * Helper functions. 50 */ 51 52 private static boolean isValidKeyboardThemeId(final int themeId) { 53 switch (themeId) { 54 case THEME_ID_ICS: 55 case THEME_ID_KLP: 56 case THEME_ID_LXX_LIGHT: 57 case THEME_ID_LXX_DARK: 58 return true; 59 default: 60 return false; 61 } 62 } 63 64 private void setKeyboardThemePreference(final String prefKey, final int themeId) { 65 final String themeIdString = Integer.toString(themeId); 66 if (isValidKeyboardThemeId(themeId) || themeId == THEME_ID_UNKNOWN) { 67 // Set valid theme id to preference. 68 mPrefs.edit().putString(prefKey, themeIdString).apply(); 69 return; 70 } 71 if (themeId == THEME_ID_NULL) { 72 // Simulate undefined preference. 73 mPrefs.edit().remove(prefKey).apply(); 74 return; 75 } 76 // themeId == THEME_ID_ILLEGAL 77 // Simulate illegal format theme id in preference. 78 mPrefs.edit().putString(prefKey, ILLEGAL_THEME_ID_STRING).apply(); 79 } 80 81 private void assertKeyboardTheme(final int sdkVersion, final int expectedThemeId) { 82 assertEquals(expectedThemeId, KeyboardTheme.getKeyboardTheme(mPrefs, sdkVersion).mThemeId); 83 } 84 85 /* 86 * Test keyboard theme preference on the same platform version and the same keyboard version. 87 */ 88 89 private void assertKeyboardThemePreference(final int sdkVersion, final int previousThemeId, 90 final int expectedThemeId) { 91 // Clear preferences before testing. 92 setKeyboardThemePreference(KeyboardTheme.KLP_KEYBOARD_THEME_KEY, THEME_ID_NULL); 93 setKeyboardThemePreference(KeyboardTheme.LXX_KEYBOARD_THEME_KEY, THEME_ID_NULL); 94 // Set the preference of the sdkVersion to previousThemeId. 95 final String prefKey = KeyboardTheme.getPreferenceKey(sdkVersion); 96 setKeyboardThemePreference(prefKey, previousThemeId); 97 assertKeyboardTheme(sdkVersion, expectedThemeId); 98 } 99 100 private void assertKeyboardThemePreferenceOnKlp(final int sdkVersion) { 101 final int defaultThemeId = THEME_ID_KLP; 102 assertKeyboardThemePreference(sdkVersion, THEME_ID_NULL, defaultThemeId); 103 assertKeyboardThemePreference(sdkVersion, THEME_ID_ICS, THEME_ID_ICS); 104 assertKeyboardThemePreference(sdkVersion, THEME_ID_KLP, THEME_ID_KLP); 105 assertKeyboardThemePreference(sdkVersion, THEME_ID_LXX_LIGHT, THEME_ID_LXX_LIGHT); 106 assertKeyboardThemePreference(sdkVersion, THEME_ID_LXX_DARK, THEME_ID_LXX_DARK); 107 assertKeyboardThemePreference(sdkVersion, THEME_ID_UNKNOWN, defaultThemeId); 108 assertKeyboardThemePreference(sdkVersion, THEME_ID_ILLEGAL, defaultThemeId); 109 } 110 111 public void testKeyboardThemePreferenceOnKlp() { 112 assertKeyboardThemePreferenceOnKlp(VERSION_CODES.ICE_CREAM_SANDWICH); 113 assertKeyboardThemePreferenceOnKlp(VERSION_CODES.ICE_CREAM_SANDWICH_MR1); 114 assertKeyboardThemePreferenceOnKlp(VERSION_CODES.JELLY_BEAN); 115 assertKeyboardThemePreferenceOnKlp(VERSION_CODES.JELLY_BEAN_MR1); 116 assertKeyboardThemePreferenceOnKlp(VERSION_CODES.JELLY_BEAN_MR2); 117 assertKeyboardThemePreferenceOnKlp(VERSION_CODES.KITKAT); 118 } 119 120 private void assertKeyboardThemePreferenceOnLxx(final int sdkVersion) { 121 final int defaultThemeId = THEME_ID_LXX_LIGHT; 122 assertKeyboardThemePreference(sdkVersion, THEME_ID_NULL, defaultThemeId); 123 assertKeyboardThemePreference(sdkVersion, THEME_ID_ICS, THEME_ID_ICS); 124 assertKeyboardThemePreference(sdkVersion, THEME_ID_KLP, THEME_ID_KLP); 125 assertKeyboardThemePreference(sdkVersion, THEME_ID_LXX_LIGHT, THEME_ID_LXX_LIGHT); 126 assertKeyboardThemePreference(sdkVersion, THEME_ID_LXX_DARK, THEME_ID_LXX_DARK); 127 assertKeyboardThemePreference(sdkVersion, THEME_ID_UNKNOWN, defaultThemeId); 128 assertKeyboardThemePreference(sdkVersion, THEME_ID_ILLEGAL, defaultThemeId); 129 } 130 131 public void testKeyboardThemePreferenceOnLxx() { 132 assertKeyboardThemePreferenceOnLxx(VERSION_CODES_LXX); 133 } 134 135 /* 136 * Test default keyboard theme based on the platform version. 137 */ 138 139 private void assertDefaultKeyboardTheme(final int sdkVersion, final int previousThemeId, 140 final int expectedThemeId) { 141 final String oldPrefKey = KeyboardTheme.KLP_KEYBOARD_THEME_KEY; 142 setKeyboardThemePreference(oldPrefKey, previousThemeId); 143 144 final KeyboardTheme defaultTheme = 145 KeyboardTheme.getDefaultKeyboardTheme(mPrefs, sdkVersion); 146 147 assertNotNull(defaultTheme); 148 assertEquals(expectedThemeId, defaultTheme.mThemeId); 149 if (sdkVersion <= VERSION_CODES.KITKAT) { 150 // Old preference must be retained if it is valid. Otherwise it must be pruned. 151 assertEquals(isValidKeyboardThemeId(previousThemeId), mPrefs.contains(oldPrefKey)); 152 return; 153 } 154 // Old preference must be removed. 155 assertFalse(mPrefs.contains(oldPrefKey)); 156 } 157 158 private void assertDefaultKeyboardThemeOnKlp(final int sdkVersion) { 159 assertDefaultKeyboardTheme(sdkVersion, THEME_ID_NULL, THEME_ID_KLP); 160 assertDefaultKeyboardTheme(sdkVersion, THEME_ID_ICS, THEME_ID_ICS); 161 assertDefaultKeyboardTheme(sdkVersion, THEME_ID_KLP, THEME_ID_KLP); 162 assertDefaultKeyboardTheme(sdkVersion, THEME_ID_UNKNOWN, THEME_ID_KLP); 163 assertDefaultKeyboardTheme(sdkVersion, THEME_ID_ILLEGAL, THEME_ID_KLP); 164 } 165 166 public void testDefaultKeyboardThemeOnKlp() { 167 assertDefaultKeyboardThemeOnKlp(VERSION_CODES.ICE_CREAM_SANDWICH); 168 assertDefaultKeyboardThemeOnKlp(VERSION_CODES.ICE_CREAM_SANDWICH_MR1); 169 assertDefaultKeyboardThemeOnKlp(VERSION_CODES.JELLY_BEAN); 170 assertDefaultKeyboardThemeOnKlp(VERSION_CODES.JELLY_BEAN_MR1); 171 assertDefaultKeyboardThemeOnKlp(VERSION_CODES.JELLY_BEAN_MR2); 172 assertDefaultKeyboardThemeOnKlp(VERSION_CODES.KITKAT); 173 } 174 175 private void assertDefaultKeyboardThemeOnLxx(final int sdkVersion) { 176 // Forced to switch to LXX theme. 177 assertDefaultKeyboardTheme(sdkVersion, THEME_ID_NULL, THEME_ID_LXX_LIGHT); 178 assertDefaultKeyboardTheme(sdkVersion, THEME_ID_ICS, THEME_ID_LXX_LIGHT); 179 assertDefaultKeyboardTheme(sdkVersion, THEME_ID_KLP, THEME_ID_LXX_LIGHT); 180 assertDefaultKeyboardTheme(sdkVersion, THEME_ID_UNKNOWN, THEME_ID_LXX_LIGHT); 181 assertDefaultKeyboardTheme(sdkVersion, THEME_ID_ILLEGAL, THEME_ID_LXX_LIGHT); 182 } 183 184 public void testDefaultKeyboardThemeOnLxx() { 185 assertDefaultKeyboardThemeOnLxx(VERSION_CODES_LXX); 186 } 187 188 /* 189 * Test keyboard theme preference while upgrading the keyboard that doesn't support LXX theme 190 * to the keyboard that supports LXX theme. 191 */ 192 193 private void assertUpgradeKeyboardToLxxOn(final int sdkVersion, final int previousThemeId, 194 final int expectedThemeId) { 195 setKeyboardThemePreference(KeyboardTheme.KLP_KEYBOARD_THEME_KEY, previousThemeId); 196 // Clean up new keyboard theme preference to simulate "upgrade to LXX keyboard". 197 setKeyboardThemePreference(KeyboardTheme.LXX_KEYBOARD_THEME_KEY, THEME_ID_NULL); 198 199 final KeyboardTheme theme = KeyboardTheme.getKeyboardTheme(mPrefs, sdkVersion); 200 201 assertNotNull(theme); 202 assertEquals(expectedThemeId, theme.mThemeId); 203 if (sdkVersion <= VERSION_CODES.KITKAT) { 204 // New preference must not exist. 205 assertFalse(mPrefs.contains(KeyboardTheme.LXX_KEYBOARD_THEME_KEY)); 206 // Old preference must be retained if it is valid. Otherwise it must be pruned. 207 assertEquals(isValidKeyboardThemeId(previousThemeId), 208 mPrefs.contains(KeyboardTheme.KLP_KEYBOARD_THEME_KEY)); 209 if (isValidKeyboardThemeId(previousThemeId)) { 210 // Old preference must have an expected value. 211 assertEquals(mPrefs.getString(KeyboardTheme.KLP_KEYBOARD_THEME_KEY, null), 212 Integer.toString(expectedThemeId)); 213 } 214 return; 215 } 216 // Old preference must be removed. 217 assertFalse(mPrefs.contains(KeyboardTheme.KLP_KEYBOARD_THEME_KEY)); 218 // New preference must not exist. 219 assertFalse(mPrefs.contains(KeyboardTheme.LXX_KEYBOARD_THEME_KEY)); 220 } 221 222 private void assertUpgradeKeyboardToLxxOnKlp(final int sdkVersion) { 223 assertUpgradeKeyboardToLxxOn(sdkVersion, THEME_ID_NULL, THEME_ID_KLP); 224 assertUpgradeKeyboardToLxxOn(sdkVersion, THEME_ID_ICS, THEME_ID_ICS); 225 assertUpgradeKeyboardToLxxOn(sdkVersion, THEME_ID_KLP, THEME_ID_KLP); 226 assertUpgradeKeyboardToLxxOn(sdkVersion, THEME_ID_UNKNOWN, THEME_ID_KLP); 227 assertUpgradeKeyboardToLxxOn(sdkVersion, THEME_ID_ILLEGAL, THEME_ID_KLP); 228 } 229 230 // Upgrading keyboard on I,J and K. 231 public void testUpgradeKeyboardToLxxOnKlp() { 232 assertUpgradeKeyboardToLxxOnKlp(VERSION_CODES.ICE_CREAM_SANDWICH); 233 assertUpgradeKeyboardToLxxOnKlp(VERSION_CODES.ICE_CREAM_SANDWICH_MR1); 234 assertUpgradeKeyboardToLxxOnKlp(VERSION_CODES.JELLY_BEAN); 235 assertUpgradeKeyboardToLxxOnKlp(VERSION_CODES.JELLY_BEAN_MR1); 236 assertUpgradeKeyboardToLxxOnKlp(VERSION_CODES.JELLY_BEAN_MR2); 237 assertUpgradeKeyboardToLxxOnKlp(VERSION_CODES.KITKAT); 238 } 239 240 private void assertUpgradeKeyboardToLxxOnLxx(final int sdkVersion) { 241 // Forced to switch to LXX theme. 242 assertUpgradeKeyboardToLxxOn(sdkVersion, THEME_ID_NULL, THEME_ID_LXX_LIGHT); 243 assertUpgradeKeyboardToLxxOn(sdkVersion, THEME_ID_ICS, THEME_ID_LXX_LIGHT); 244 assertUpgradeKeyboardToLxxOn(sdkVersion, THEME_ID_KLP, THEME_ID_LXX_LIGHT); 245 assertUpgradeKeyboardToLxxOn(sdkVersion, THEME_ID_UNKNOWN, THEME_ID_LXX_LIGHT); 246 assertUpgradeKeyboardToLxxOn(sdkVersion, THEME_ID_ILLEGAL, THEME_ID_LXX_LIGHT); 247 } 248 249 // Upgrading keyboard on L. 250 public void testUpgradeKeyboardToLxxOnLxx() { 251 assertUpgradeKeyboardToLxxOnLxx(VERSION_CODES_LXX); 252 } 253 254 /* 255 * Test keyboard theme preference while upgrading platform version. 256 */ 257 258 private void assertUpgradePlatformFromTo(final int oldSdkVersion, final int newSdkVersion, 259 final int previousThemeId, final int expectedThemeId) { 260 if (newSdkVersion < oldSdkVersion) { 261 // No need to test. 262 return; 263 } 264 // Clean up preferences. 265 setKeyboardThemePreference(KeyboardTheme.KLP_KEYBOARD_THEME_KEY, THEME_ID_NULL); 266 setKeyboardThemePreference(KeyboardTheme.LXX_KEYBOARD_THEME_KEY, THEME_ID_NULL); 267 268 final String oldPrefKey = KeyboardTheme.getPreferenceKey(oldSdkVersion); 269 setKeyboardThemePreference(oldPrefKey, previousThemeId); 270 271 assertKeyboardTheme(newSdkVersion, expectedThemeId); 272 } 273 274 private void assertUpgradePlatformFromKlpToKlp(final int oldSdkVersion, 275 final int newSdkVersion) { 276 assertUpgradePlatformFromTo(oldSdkVersion, newSdkVersion, THEME_ID_NULL, THEME_ID_KLP); 277 assertUpgradePlatformFromTo(oldSdkVersion, newSdkVersion, THEME_ID_ICS, THEME_ID_ICS); 278 assertUpgradePlatformFromTo(oldSdkVersion, newSdkVersion, THEME_ID_KLP, THEME_ID_KLP); 279 assertUpgradePlatformFromTo(oldSdkVersion, newSdkVersion, THEME_ID_UNKNOWN, THEME_ID_KLP); 280 assertUpgradePlatformFromTo(oldSdkVersion, newSdkVersion, THEME_ID_ILLEGAL, THEME_ID_KLP); 281 } 282 283 private void assertUpgradePlatformToKlpFrom(final int oldSdkVersion) { 284 assertUpgradePlatformFromKlpToKlp(oldSdkVersion, VERSION_CODES.ICE_CREAM_SANDWICH); 285 assertUpgradePlatformFromKlpToKlp(oldSdkVersion, VERSION_CODES.ICE_CREAM_SANDWICH_MR1); 286 assertUpgradePlatformFromKlpToKlp(oldSdkVersion, VERSION_CODES.JELLY_BEAN); 287 assertUpgradePlatformFromKlpToKlp(oldSdkVersion, VERSION_CODES.JELLY_BEAN_MR1); 288 assertUpgradePlatformFromKlpToKlp(oldSdkVersion, VERSION_CODES.JELLY_BEAN_MR2); 289 assertUpgradePlatformFromKlpToKlp(oldSdkVersion, VERSION_CODES.KITKAT); 290 } 291 292 // Update platform from I,J, and K to I,J, and K 293 public void testUpgradePlatformToKlpFromKlp() { 294 assertUpgradePlatformToKlpFrom(VERSION_CODES.ICE_CREAM_SANDWICH); 295 assertUpgradePlatformToKlpFrom(VERSION_CODES.ICE_CREAM_SANDWICH_MR1); 296 assertUpgradePlatformToKlpFrom(VERSION_CODES.JELLY_BEAN); 297 assertUpgradePlatformToKlpFrom(VERSION_CODES.JELLY_BEAN_MR1); 298 assertUpgradePlatformToKlpFrom(VERSION_CODES.JELLY_BEAN_MR2); 299 assertUpgradePlatformToKlpFrom(VERSION_CODES.KITKAT); 300 } 301 302 private void assertUpgradePlatformToLxxFrom(final int oldSdkVersion) { 303 // Forced to switch to LXX theme. 304 final int newSdkVersion = VERSION_CODES_LXX; 305 assertUpgradePlatformFromTo( 306 oldSdkVersion, newSdkVersion, THEME_ID_NULL, THEME_ID_LXX_LIGHT); 307 assertUpgradePlatformFromTo( 308 oldSdkVersion, newSdkVersion, THEME_ID_ICS, THEME_ID_LXX_LIGHT); 309 assertUpgradePlatformFromTo( 310 oldSdkVersion, newSdkVersion, THEME_ID_KLP, THEME_ID_LXX_LIGHT); 311 assertUpgradePlatformFromTo( 312 oldSdkVersion, newSdkVersion, THEME_ID_UNKNOWN, THEME_ID_LXX_LIGHT); 313 assertUpgradePlatformFromTo( 314 oldSdkVersion, newSdkVersion, THEME_ID_ILLEGAL, THEME_ID_LXX_LIGHT); 315 } 316 317 // Update platform from I,J, and K to L 318 public void testUpgradePlatformToLxx() { 319 assertUpgradePlatformToLxxFrom(VERSION_CODES.ICE_CREAM_SANDWICH); 320 assertUpgradePlatformToLxxFrom(VERSION_CODES.ICE_CREAM_SANDWICH_MR1); 321 assertUpgradePlatformToLxxFrom(VERSION_CODES.JELLY_BEAN); 322 assertUpgradePlatformToLxxFrom(VERSION_CODES.JELLY_BEAN_MR1); 323 assertUpgradePlatformToLxxFrom(VERSION_CODES.JELLY_BEAN_MR2); 324 assertUpgradePlatformToLxxFrom(VERSION_CODES.KITKAT); 325 } 326 327 // Update platform from L to L. 328 public void testUpgradePlatformToLxxFromLxx() { 329 final int oldSdkVersion = VERSION_CODES_LXX; 330 final int newSdkVersion = VERSION_CODES_LXX; 331 assertUpgradePlatformFromTo( 332 oldSdkVersion, newSdkVersion, THEME_ID_NULL, THEME_ID_LXX_LIGHT); 333 assertUpgradePlatformFromTo( 334 oldSdkVersion, newSdkVersion, THEME_ID_ICS, THEME_ID_ICS); 335 assertUpgradePlatformFromTo( 336 oldSdkVersion, newSdkVersion, THEME_ID_KLP, THEME_ID_KLP); 337 assertUpgradePlatformFromTo( 338 oldSdkVersion, newSdkVersion, THEME_ID_LXX_LIGHT, THEME_ID_LXX_LIGHT); 339 assertUpgradePlatformFromTo( 340 oldSdkVersion, newSdkVersion, THEME_ID_LXX_DARK, THEME_ID_LXX_DARK); 341 assertUpgradePlatformFromTo( 342 oldSdkVersion, newSdkVersion, THEME_ID_UNKNOWN, THEME_ID_LXX_LIGHT); 343 assertUpgradePlatformFromTo( 344 oldSdkVersion, newSdkVersion, THEME_ID_ILLEGAL, THEME_ID_LXX_LIGHT); 345 } 346} 347