SubtypeLocaleUtilsTests.java revision 2202d47386598815c7bda939f36759e7b923cc61
1/* 2 * Copyright (C) 2011 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.latin.utils; 18 19import android.content.Context; 20import android.content.res.Resources; 21import android.test.AndroidTestCase; 22import android.test.suitebuilder.annotation.SmallTest; 23import android.view.inputmethod.InputMethodInfo; 24import android.view.inputmethod.InputMethodSubtype; 25 26import com.android.inputmethod.latin.RichInputMethodManager; 27 28import java.util.ArrayList; 29import java.util.Locale; 30 31@SmallTest 32public class SubtypeLocaleUtilsTests extends AndroidTestCase { 33 // All input method subtypes of LatinIME. 34 private final ArrayList<InputMethodSubtype> mSubtypesList = CollectionUtils.newArrayList(); 35 36 private RichInputMethodManager mRichImm; 37 private Resources mRes; 38 39 InputMethodSubtype EN_US; 40 InputMethodSubtype EN_GB; 41 InputMethodSubtype ES_US; 42 InputMethodSubtype FR; 43 InputMethodSubtype FR_CA; 44 InputMethodSubtype FR_CH; 45 InputMethodSubtype DE; 46 InputMethodSubtype DE_CH; 47 InputMethodSubtype ZZ; 48 InputMethodSubtype DE_QWERTY; 49 InputMethodSubtype FR_QWERTZ; 50 InputMethodSubtype EN_US_AZERTY; 51 InputMethodSubtype EN_UK_DVORAK; 52 InputMethodSubtype ES_US_COLEMAK; 53 InputMethodSubtype ZZ_AZERTY; 54 InputMethodSubtype ZZ_PC; 55 56 @Override 57 protected void setUp() throws Exception { 58 super.setUp(); 59 final Context context = getContext(); 60 RichInputMethodManager.init(context); 61 mRichImm = RichInputMethodManager.getInstance(); 62 mRes = context.getResources(); 63 SubtypeLocaleUtils.init(context); 64 65 final InputMethodInfo imi = mRichImm.getInputMethodInfoOfThisIme(); 66 final int subtypeCount = imi.getSubtypeCount(); 67 for (int index = 0; index < subtypeCount; index++) { 68 final InputMethodSubtype subtype = imi.getSubtypeAt(index); 69 mSubtypesList.add(subtype); 70 } 71 72 EN_US = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet( 73 Locale.US.toString(), "qwerty"); 74 EN_GB = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet( 75 Locale.UK.toString(), "qwerty"); 76 ES_US = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet( 77 "es_US", "spanish"); 78 FR = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet( 79 Locale.FRENCH.toString(), "azerty"); 80 FR_CA = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet( 81 Locale.CANADA_FRENCH.toString(), "qwerty"); 82 FR_CH = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet( 83 "fr_CH", "swiss"); 84 DE = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet( 85 Locale.GERMAN.toString(), "qwertz"); 86 DE_CH = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet( 87 "de_CH", "swiss"); 88 ZZ = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet( 89 SubtypeLocaleUtils.NO_LANGUAGE, "qwerty"); 90 DE_QWERTY = AdditionalSubtypeUtils.createAdditionalSubtype( 91 Locale.GERMAN.toString(), "qwerty", null); 92 FR_QWERTZ = AdditionalSubtypeUtils.createAdditionalSubtype( 93 Locale.FRENCH.toString(), "qwertz", null); 94 EN_US_AZERTY = AdditionalSubtypeUtils.createAdditionalSubtype( 95 Locale.US.toString(), "azerty", null); 96 EN_UK_DVORAK = AdditionalSubtypeUtils.createAdditionalSubtype( 97 Locale.UK.toString(), "dvorak", null); 98 ES_US_COLEMAK = AdditionalSubtypeUtils.createAdditionalSubtype( 99 "es_US", "colemak", null); 100 ZZ_AZERTY = AdditionalSubtypeUtils.createAdditionalSubtype( 101 SubtypeLocaleUtils.NO_LANGUAGE, "azerty", null); 102 ZZ_PC = AdditionalSubtypeUtils.createAdditionalSubtype( 103 SubtypeLocaleUtils.NO_LANGUAGE, "pcqwerty", null); 104 } 105 106 public void testAllFullDisplayName() { 107 for (final InputMethodSubtype subtype : mSubtypesList) { 108 final String subtypeName = SubtypeLocaleUtils 109 .getSubtypeDisplayNameInSystemLocale(subtype); 110 if (SubtypeLocaleUtils.isNoLanguage(subtype)) { 111 final String layoutName = SubtypeLocaleUtils 112 .getKeyboardLayoutSetDisplayName(subtype); 113 assertTrue(subtypeName, subtypeName.contains(layoutName)); 114 } else { 115 final String languageName = SubtypeLocaleUtils 116 .getSubtypeLocaleDisplayNameInSystemLocale(subtype.getLocale()); 117 assertTrue(subtypeName, subtypeName.contains(languageName)); 118 } 119 } 120 } 121 122 public void testKeyboardLayoutSetName() { 123 assertEquals("en_US", "qwerty", SubtypeLocaleUtils.getKeyboardLayoutSetName(EN_US)); 124 assertEquals("en_GB", "qwerty", SubtypeLocaleUtils.getKeyboardLayoutSetName(EN_GB)); 125 assertEquals("es_US", "spanish", SubtypeLocaleUtils.getKeyboardLayoutSetName(ES_US)); 126 assertEquals("fr ", "azerty", SubtypeLocaleUtils.getKeyboardLayoutSetName(FR)); 127 assertEquals("fr_CA", "qwerty", SubtypeLocaleUtils.getKeyboardLayoutSetName(FR_CA)); 128 assertEquals("fr_CH", "swiss", SubtypeLocaleUtils.getKeyboardLayoutSetName(FR_CH)); 129 assertEquals("de ", "qwertz", SubtypeLocaleUtils.getKeyboardLayoutSetName(DE)); 130 assertEquals("de_CH", "swiss", SubtypeLocaleUtils.getKeyboardLayoutSetName(DE_CH)); 131 assertEquals("zz ", "qwerty", SubtypeLocaleUtils.getKeyboardLayoutSetName(ZZ)); 132 } 133 134 // InputMethodSubtype's display name in system locale (en_US). 135 // isAdditionalSubtype (T=true, F=false) 136 // locale layout | display name 137 // ------ ------- - ---------------------- 138 // en_US qwerty F English (US) exception 139 // en_GB qwerty F English (UK) exception 140 // es_US spanish F Spanish (US) exception 141 // fr azerty F French 142 // fr_CA qwerty F French (Canada) 143 // fr_CH swiss F French (Switzerland) 144 // de qwertz F German 145 // de_CH swiss F German (Switzerland) 146 // zz qwerty F Alphabet (QWERTY) 147 // fr qwertz T French (QWERTZ) 148 // de qwerty T German (QWERTY) 149 // en_US azerty T English (US) (AZERTY) exception 150 // en_UK dvorak T English (UK) (Dvorak) exception 151 // es_US colemak T Spanish (US) (Colemak) exception 152 // zz pc T Alphabet (PC) 153 154 public void testPredefinedSubtypesInEnglishSystemLocale() { 155 final RunInLocale<Void> tests = new RunInLocale<Void>() { 156 @Override 157 protected Void job(final Resources res) { 158 assertEquals("en_US", "English (US)", 159 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(EN_US)); 160 assertEquals("en_GB", "English (UK)", 161 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(EN_GB)); 162 assertEquals("es_US", "Spanish (US)", 163 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(ES_US)); 164 assertEquals("fr ", "French", 165 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(FR)); 166 assertEquals("fr_CA", "French (Canada)", 167 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(FR_CA)); 168 assertEquals("fr_CH", "French (Switzerland)", 169 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(FR_CH)); 170 assertEquals("de ", "German", 171 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(DE)); 172 assertEquals("de_CH", "German (Switzerland)", 173 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(DE_CH)); 174 assertEquals("zz ", "Alphabet (QWERTY)", 175 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(ZZ)); 176 return null; 177 } 178 }; 179 tests.runInLocale(mRes, Locale.ENGLISH); 180 } 181 182 public void testAdditionalSubtypesInEnglishSystemLocale() { 183 final RunInLocale<Void> tests = new RunInLocale<Void>() { 184 @Override 185 protected Void job(final Resources res) { 186 assertEquals("fr qwertz", "French (QWERTZ)", 187 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(FR_QWERTZ)); 188 assertEquals("de qwerty", "German (QWERTY)", 189 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(DE_QWERTY)); 190 assertEquals("en_US azerty", "English (US) (AZERTY)", 191 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(EN_US_AZERTY)); 192 assertEquals("en_UK dvorak", "English (UK) (Dvorak)", 193 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(EN_UK_DVORAK)); 194 assertEquals("es_US colemak","Spanish (US) (Colemak)", 195 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(ES_US_COLEMAK)); 196 assertEquals("zz pc", "Alphabet (PC)", 197 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(ZZ_PC)); 198 return null; 199 } 200 }; 201 tests.runInLocale(mRes, Locale.ENGLISH); 202 } 203 204 // InputMethodSubtype's display name in system locale (fr). 205 // isAdditionalSubtype (T=true, F=false) 206 // locale layout | display name 207 // ------ ------- - ---------------------- 208 // en_US qwerty F Anglais (États-Unis) exception 209 // en_GB qwerty F Anglais (Royaume-Uni) exception 210 // es_US spanish F Espagnol (États-Unis) exception 211 // fr azerty F Français 212 // fr_CA qwerty F Français (Canada) 213 // fr_CH swiss F Français (Suisse) 214 // de qwertz F Allemand 215 // de_CH swiss F Allemand (Suisse) 216 // zz qwerty F Alphabet latin (QWERTY) 217 // fr qwertz T Français (QWERTZ) 218 // de qwerty T Allemand (QWERTY) 219 // en_US azerty T Anglais (États-Unis) (AZERTY) exception 220 // en_UK dvorak T Anglais (Royaume-Uni) (Dvorak) exception 221 // es_US colemak T Espagnol (États-Unis) (Colemak) exception 222 // zz pc T Alphabet latin (PC) 223 224 public void testPredefinedSubtypesInFrenchSystemLocale() { 225 final RunInLocale<Void> tests = new RunInLocale<Void>() { 226 @Override 227 protected Void job(final Resources res) { 228 assertEquals("en_US", "Anglais (États-Unis)", 229 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(EN_US)); 230 assertEquals("en_GB", "Anglais (Royaume-Uni)", 231 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(EN_GB)); 232 assertEquals("es_US", "Espagnol (États-Unis)", 233 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(ES_US)); 234 assertEquals("fr ", "Français", 235 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(FR)); 236 assertEquals("fr_CA", "Français (Canada)", 237 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(FR_CA)); 238 assertEquals("fr_CH", "Français (Suisse)", 239 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(FR_CH)); 240 assertEquals("de ", "Allemand", 241 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(DE)); 242 assertEquals("de_CH", "Allemand (Suisse)", 243 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(DE_CH)); 244 assertEquals("zz ", "Alphabet latin (QWERTY)", 245 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(ZZ)); 246 return null; 247 } 248 }; 249 tests.runInLocale(mRes, Locale.FRENCH); 250 } 251 252 public void testAdditionalSubtypesInFrenchSystemLocale() { 253 final RunInLocale<Void> tests = new RunInLocale<Void>() { 254 @Override 255 protected Void job(final Resources res) { 256 assertEquals("fr qwertz", "Français (QWERTZ)", 257 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(FR_QWERTZ)); 258 assertEquals("de qwerty", "Allemand (QWERTY)", 259 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(DE_QWERTY)); 260 assertEquals("en_US azerty", "Anglais (États-Unis) (AZERTY)", 261 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(EN_US_AZERTY)); 262 assertEquals("en_UK dvorak", "Anglais (Royaume-Uni) (Dvorak)", 263 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(EN_UK_DVORAK)); 264 assertEquals("es_US colemak","Espagnol (États-Unis) (Colemak)", 265 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(ES_US_COLEMAK)); 266 assertEquals("zz pc", "Alphabet latin (PC)", 267 SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(ZZ_PC)); 268 return null; 269 } 270 }; 271 tests.runInLocale(mRes, Locale.FRENCH); 272 } 273 274 public void testAllFullDisplayNameForSpacebar() { 275 for (final InputMethodSubtype subtype : mSubtypesList) { 276 final String subtypeName = SubtypeLocaleUtils 277 .getSubtypeDisplayNameInSystemLocale(subtype); 278 final String spacebarText = SubtypeLocaleUtils.getFullDisplayName(subtype); 279 final String languageName = SubtypeLocaleUtils 280 .getSubtypeLocaleDisplayName(subtype.getLocale()); 281 if (SubtypeLocaleUtils.isNoLanguage(subtype)) { 282 assertFalse(subtypeName, spacebarText.contains(languageName)); 283 } else { 284 assertTrue(subtypeName, spacebarText.contains(languageName)); 285 } 286 } 287 } 288 289 public void testAllMiddleDisplayNameForSpacebar() { 290 for (final InputMethodSubtype subtype : mSubtypesList) { 291 final String subtypeName = SubtypeLocaleUtils 292 .getSubtypeDisplayNameInSystemLocale(subtype); 293 final String spacebarText = SubtypeLocaleUtils.getMiddleDisplayName(subtype); 294 if (SubtypeLocaleUtils.isNoLanguage(subtype)) { 295 assertEquals(subtypeName, 296 SubtypeLocaleUtils.getKeyboardLayoutSetDisplayName(subtype), spacebarText); 297 } else { 298 final Locale locale = SubtypeLocaleUtils.getSubtypeLocale(subtype); 299 assertEquals(subtypeName, 300 SubtypeLocaleUtils.getSubtypeLocaleDisplayName(locale.getLanguage()), 301 spacebarText); 302 } 303 } 304 } 305 306 // InputMethodSubtype's display name for spacebar text in its locale. 307 // isAdditionalSubtype (T=true, F=false) 308 // locale layout | Middle Full 309 // ------ ------- - --------- ---------------------- 310 // en_US qwerty F English English (US) exception 311 // en_GB qwerty F English English (UK) exception 312 // es_US spanish F Español Español (EE.UU.) exception 313 // fr azerty F Français Français 314 // fr_CA qwerty F Français Français (Canada) 315 // fr_CH swiss F Français Français (Suisse) 316 // de qwertz F Deutsch Deutsch 317 // de_CH swiss F Deutsch Deutsch (Schweiz) 318 // zz qwerty F QWERTY QWERTY 319 // fr qwertz T Français Français 320 // de qwerty T Deutsch Deutsch 321 // en_US azerty T English English (US) 322 // zz azerty T AZERTY AZERTY 323 324 private final RunInLocale<Void> testsPredefinedSubtypesForSpacebar = new RunInLocale<Void>() { 325 @Override 326 protected Void job(final Resources res) { 327 assertEquals("en_US", "English (US)", SubtypeLocaleUtils.getFullDisplayName(EN_US)); 328 assertEquals("en_GB", "English (UK)", SubtypeLocaleUtils.getFullDisplayName(EN_GB)); 329 assertEquals("es_US", "Español (EE.UU.)", 330 SubtypeLocaleUtils.getFullDisplayName(ES_US)); 331 assertEquals("fr ", "Français", SubtypeLocaleUtils.getFullDisplayName(FR)); 332 assertEquals("fr_CA", "Français (Canada)", 333 SubtypeLocaleUtils.getFullDisplayName(FR_CA)); 334 assertEquals("fr_CH", "Français (Suisse)", 335 SubtypeLocaleUtils.getFullDisplayName(FR_CH)); 336 assertEquals("de ", "Deutsch", SubtypeLocaleUtils.getFullDisplayName(DE)); 337 assertEquals("de_CH", "Deutsch (Schweiz)", 338 SubtypeLocaleUtils.getFullDisplayName(DE_CH)); 339 assertEquals("zz ", "QWERTY", SubtypeLocaleUtils.getFullDisplayName(ZZ)); 340 341 assertEquals("en_US", "English", SubtypeLocaleUtils.getMiddleDisplayName(EN_US)); 342 assertEquals("en_GB", "English", SubtypeLocaleUtils.getMiddleDisplayName(EN_GB)); 343 assertEquals("es_US", "Español", SubtypeLocaleUtils.getMiddleDisplayName(ES_US)); 344 assertEquals("fr ", "Français", SubtypeLocaleUtils.getMiddleDisplayName(FR)); 345 assertEquals("fr_CA", "Français", SubtypeLocaleUtils.getMiddleDisplayName(FR_CA)); 346 assertEquals("fr_CH", "Français", SubtypeLocaleUtils.getMiddleDisplayName(FR_CH)); 347 assertEquals("de ", "Deutsch", SubtypeLocaleUtils.getMiddleDisplayName(DE)); 348 assertEquals("de_CH", "Deutsch", SubtypeLocaleUtils.getMiddleDisplayName(DE_CH)); 349 assertEquals("zz ", "QWERTY", SubtypeLocaleUtils.getMiddleDisplayName(ZZ)); 350 return null; 351 } 352 }; 353 354 private final RunInLocale<Void> testsAdditionalSubtypesForSpacebar = new RunInLocale<Void>() { 355 @Override 356 protected Void job(final Resources res) { 357 assertEquals("fr qwertz", "Français", 358 SubtypeLocaleUtils.getFullDisplayName(FR_QWERTZ)); 359 assertEquals("de qwerty", "Deutsch", 360 SubtypeLocaleUtils.getFullDisplayName(DE_QWERTY)); 361 assertEquals("en_US azerty", "English (US)", 362 SubtypeLocaleUtils.getFullDisplayName(EN_US_AZERTY)); 363 assertEquals("zz azerty", "AZERTY", 364 SubtypeLocaleUtils.getFullDisplayName(ZZ_AZERTY)); 365 366 assertEquals("fr qwertz", "Français", 367 SubtypeLocaleUtils.getMiddleDisplayName(FR_QWERTZ)); 368 assertEquals("de qwerty", "Deutsch", 369 SubtypeLocaleUtils.getMiddleDisplayName(DE_QWERTY)); 370 assertEquals("en_US azerty", "English", 371 SubtypeLocaleUtils.getMiddleDisplayName(EN_US_AZERTY)); 372 assertEquals("zz azerty", "AZERTY", 373 SubtypeLocaleUtils.getMiddleDisplayName(ZZ_AZERTY)); 374 return null; 375 } 376 }; 377 378 public void testPredefinedSubtypesForSpacebarInEnglish() { 379 testsPredefinedSubtypesForSpacebar.runInLocale(mRes, Locale.ENGLISH); 380 } 381 382 public void testAdditionalSubtypeForSpacebarInEnglish() { 383 testsAdditionalSubtypesForSpacebar.runInLocale(mRes, Locale.ENGLISH); 384 } 385 386 public void testPredefinedSubtypesForSpacebarInFrench() { 387 testsPredefinedSubtypesForSpacebar.runInLocale(mRes, Locale.FRENCH); 388 } 389 390 public void testAdditionalSubtypeForSpacebarInFrench() { 391 testsAdditionalSubtypesForSpacebar.runInLocale(mRes, Locale.FRENCH); 392 } 393 394 public void testIsRtlLanguage() { 395 // Known Right-to-Left language subtypes. 396 final InputMethodSubtype ARABIC = mRichImm 397 .findSubtypeByLocaleAndKeyboardLayoutSet("ar", "arabic"); 398 assertNotNull("Arabic", ARABIC); 399 final InputMethodSubtype FARSI = mRichImm 400 .findSubtypeByLocaleAndKeyboardLayoutSet("fa", "farsi"); 401 assertNotNull("Farsi", FARSI); 402 final InputMethodSubtype HEBREW = mRichImm 403 .findSubtypeByLocaleAndKeyboardLayoutSet("iw", "hebrew"); 404 assertNotNull("Hebrew", HEBREW); 405 406 for (final InputMethodSubtype subtype : mSubtypesList) { 407 final String subtypeName = SubtypeLocaleUtils 408 .getSubtypeDisplayNameInSystemLocale(subtype); 409 if (subtype.equals(ARABIC) || subtype.equals(FARSI) || subtype.equals(HEBREW)) { 410 assertTrue(subtypeName, SubtypeLocaleUtils.isRtlLanguage(subtype)); 411 } else { 412 assertFalse(subtypeName, SubtypeLocaleUtils.isRtlLanguage(subtype)); 413 } 414 } 415 } 416} 417