499 lines
25 KiB
Java
499 lines
25 KiB
Java
/*
|
|
* Copyright (C) 2011 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package com.android.inputmethod.latin.utils;
|
|
|
|
import static org.junit.Assert.assertEquals;
|
|
import static org.junit.Assert.assertFalse;
|
|
import static org.junit.Assert.assertNotNull;
|
|
import static org.junit.Assert.assertTrue;
|
|
|
|
import android.content.Context;
|
|
import android.content.res.Resources;
|
|
import android.view.inputmethod.InputMethodInfo;
|
|
import android.view.inputmethod.InputMethodSubtype;
|
|
|
|
import androidx.test.InstrumentationRegistry;
|
|
import androidx.test.filters.SmallTest;
|
|
import androidx.test.runner.AndroidJUnit4;
|
|
|
|
import com.android.inputmethod.latin.R;
|
|
import com.android.inputmethod.latin.RichInputMethodManager;
|
|
import com.android.inputmethod.latin.RichInputMethodSubtype;
|
|
|
|
import org.junit.After;
|
|
import org.junit.Before;
|
|
import org.junit.Test;
|
|
import org.junit.runner.RunWith;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Locale;
|
|
|
|
@SmallTest
|
|
@RunWith(AndroidJUnit4.class)
|
|
public class SubtypeLocaleUtilsTests {
|
|
// All input method subtypes of LatinIME.
|
|
private final ArrayList<RichInputMethodSubtype> mSubtypesList = new ArrayList<>();
|
|
|
|
private RichInputMethodManager mRichImm;
|
|
private Resources mRes;
|
|
private InputMethodSubtype mSavedAddtionalSubtypes[];
|
|
|
|
InputMethodSubtype EN_US;
|
|
InputMethodSubtype EN_GB;
|
|
InputMethodSubtype ES_US;
|
|
InputMethodSubtype FR;
|
|
InputMethodSubtype FR_CA;
|
|
InputMethodSubtype FR_CH;
|
|
InputMethodSubtype DE;
|
|
InputMethodSubtype DE_CH;
|
|
InputMethodSubtype HI;
|
|
InputMethodSubtype SR;
|
|
InputMethodSubtype ZZ;
|
|
InputMethodSubtype DE_QWERTY;
|
|
InputMethodSubtype FR_QWERTZ;
|
|
InputMethodSubtype EN_US_AZERTY;
|
|
InputMethodSubtype EN_UK_DVORAK;
|
|
InputMethodSubtype ES_US_COLEMAK;
|
|
InputMethodSubtype ZZ_AZERTY;
|
|
InputMethodSubtype ZZ_PC;
|
|
|
|
// These are preliminary subtypes and may not exist.
|
|
InputMethodSubtype HI_LATN; // Hinglish
|
|
InputMethodSubtype SR_LATN; // Serbian Latin
|
|
InputMethodSubtype HI_LATN_DVORAK; // Hinglis Dvorak
|
|
InputMethodSubtype SR_LATN_QWERTY; // Serbian Latin Qwerty
|
|
|
|
@Before
|
|
public void setUp() throws Exception {
|
|
final Context context = InstrumentationRegistry.getTargetContext();
|
|
mRes = context.getResources();
|
|
RichInputMethodManager.init(context);
|
|
mRichImm = RichInputMethodManager.getInstance();
|
|
|
|
// Save and reset additional subtypes
|
|
mSavedAddtionalSubtypes = mRichImm.getAdditionalSubtypes();
|
|
final InputMethodSubtype[] predefinedAddtionalSubtypes =
|
|
AdditionalSubtypeUtils.createAdditionalSubtypesArray(
|
|
AdditionalSubtypeUtils.createPrefSubtypes(
|
|
mRes.getStringArray(R.array.predefined_subtypes)));
|
|
mRichImm.setAdditionalInputMethodSubtypes(predefinedAddtionalSubtypes);
|
|
|
|
final InputMethodInfo imi = mRichImm.getInputMethodInfoOfThisIme();
|
|
final int subtypeCount = imi.getSubtypeCount();
|
|
for (int index = 0; index < subtypeCount; index++) {
|
|
final InputMethodSubtype subtype = imi.getSubtypeAt(index);
|
|
mSubtypesList.add(new RichInputMethodSubtype(subtype));
|
|
}
|
|
|
|
EN_US = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet(
|
|
Locale.US.toString(), "qwerty");
|
|
EN_GB = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet(
|
|
Locale.UK.toString(), "qwerty");
|
|
ES_US = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet(
|
|
"es_US", "spanish");
|
|
FR = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet(
|
|
Locale.FRENCH.toString(), "azerty");
|
|
FR_CA = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet(
|
|
Locale.CANADA_FRENCH.toString(), "qwerty");
|
|
FR_CH = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet(
|
|
"fr_CH", "swiss");
|
|
DE = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet(
|
|
Locale.GERMAN.toString(), "qwertz");
|
|
DE_CH = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet(
|
|
"de_CH", "swiss");
|
|
HI = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet(
|
|
"hi", "hindi");
|
|
SR = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet(
|
|
"sr", "south_slavic");
|
|
ZZ = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet(
|
|
SubtypeLocaleUtils.NO_LANGUAGE, "qwerty");
|
|
DE_QWERTY = AdditionalSubtypeUtils.createAsciiEmojiCapableAdditionalSubtype(
|
|
Locale.GERMAN.toString(), "qwerty");
|
|
FR_QWERTZ = AdditionalSubtypeUtils.createAsciiEmojiCapableAdditionalSubtype(
|
|
Locale.FRENCH.toString(), "qwertz");
|
|
EN_US_AZERTY = AdditionalSubtypeUtils.createAsciiEmojiCapableAdditionalSubtype(
|
|
Locale.US.toString(), "azerty");
|
|
EN_UK_DVORAK = AdditionalSubtypeUtils.createAsciiEmojiCapableAdditionalSubtype(
|
|
Locale.UK.toString(), "dvorak");
|
|
ES_US_COLEMAK = AdditionalSubtypeUtils.createAsciiEmojiCapableAdditionalSubtype(
|
|
"es_US", "colemak");
|
|
ZZ_AZERTY = AdditionalSubtypeUtils.createAsciiEmojiCapableAdditionalSubtype(
|
|
SubtypeLocaleUtils.NO_LANGUAGE, "azerty");
|
|
ZZ_PC = AdditionalSubtypeUtils.createAsciiEmojiCapableAdditionalSubtype(
|
|
SubtypeLocaleUtils.NO_LANGUAGE, "pcqwerty");
|
|
|
|
HI_LATN = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet("hi_ZZ", "qwerty");
|
|
if (HI_LATN != null) {
|
|
HI_LATN_DVORAK = AdditionalSubtypeUtils.createAsciiEmojiCapableAdditionalSubtype(
|
|
"hi_ZZ", "dvorak");
|
|
}
|
|
SR_LATN = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet("sr_ZZ", "serbian_qwertz");
|
|
if (SR_LATN != null) {
|
|
SR_LATN_QWERTY = AdditionalSubtypeUtils.createAsciiEmojiCapableAdditionalSubtype(
|
|
"sr_ZZ", "qwerty");
|
|
}
|
|
}
|
|
|
|
@After
|
|
public void tearDown() throws Exception {
|
|
// Restore additional subtypes.
|
|
mRichImm.setAdditionalInputMethodSubtypes(mSavedAddtionalSubtypes);
|
|
}
|
|
|
|
@Test
|
|
public void testAllFullDisplayName() {
|
|
for (final RichInputMethodSubtype subtype : mSubtypesList) {
|
|
final String subtypeName = SubtypeLocaleUtils
|
|
.getSubtypeDisplayNameInSystemLocale(subtype.getRawSubtype());
|
|
if (subtype.isNoLanguage()) {
|
|
final String layoutName = SubtypeLocaleUtils
|
|
.getKeyboardLayoutSetDisplayName(subtype.getRawSubtype());
|
|
assertTrue(subtypeName, subtypeName.contains(layoutName));
|
|
} else {
|
|
final String languageName = SubtypeLocaleUtils
|
|
.getSubtypeLocaleDisplayNameInSystemLocale(subtype.getLocale().toString());
|
|
assertTrue(subtypeName, subtypeName.contains(languageName));
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testKeyboardLayoutSetName() {
|
|
assertEquals("en_US", "qwerty", SubtypeLocaleUtils.getKeyboardLayoutSetName(EN_US));
|
|
assertEquals("en_GB", "qwerty", SubtypeLocaleUtils.getKeyboardLayoutSetName(EN_GB));
|
|
assertEquals("es_US", "spanish", SubtypeLocaleUtils.getKeyboardLayoutSetName(ES_US));
|
|
assertEquals("fr", "azerty", SubtypeLocaleUtils.getKeyboardLayoutSetName(FR));
|
|
assertEquals("fr_CA", "qwerty", SubtypeLocaleUtils.getKeyboardLayoutSetName(FR_CA));
|
|
assertEquals("fr_CH", "swiss", SubtypeLocaleUtils.getKeyboardLayoutSetName(FR_CH));
|
|
assertEquals("de", "qwertz", SubtypeLocaleUtils.getKeyboardLayoutSetName(DE));
|
|
assertEquals("de_CH", "swiss", SubtypeLocaleUtils.getKeyboardLayoutSetName(DE_CH));
|
|
assertEquals("hi", "hindi", SubtypeLocaleUtils.getKeyboardLayoutSetName(HI));
|
|
assertEquals("sr", "south_slavic", SubtypeLocaleUtils.getKeyboardLayoutSetName(SR));
|
|
assertEquals("zz", "qwerty", SubtypeLocaleUtils.getKeyboardLayoutSetName(ZZ));
|
|
|
|
assertEquals("de qwerty", "qwerty", SubtypeLocaleUtils.getKeyboardLayoutSetName(DE_QWERTY));
|
|
assertEquals("fr qwertz", "qwertz", SubtypeLocaleUtils.getKeyboardLayoutSetName(FR_QWERTZ));
|
|
assertEquals("en_US azerty", "azerty",
|
|
SubtypeLocaleUtils.getKeyboardLayoutSetName(EN_US_AZERTY));
|
|
assertEquals("en_UK dvorak", "dvorak",
|
|
SubtypeLocaleUtils.getKeyboardLayoutSetName(EN_UK_DVORAK));
|
|
assertEquals("es_US colemak", "colemak",
|
|
SubtypeLocaleUtils.getKeyboardLayoutSetName(ES_US_COLEMAK));
|
|
assertEquals("zz azerty", "azerty",
|
|
SubtypeLocaleUtils.getKeyboardLayoutSetName(ZZ_AZERTY));
|
|
|
|
// These are preliminary subtypes and may not exist.
|
|
if (HI_LATN != null) {
|
|
assertEquals("hi_ZZ", "qwerty", SubtypeLocaleUtils.getKeyboardLayoutSetName(HI_LATN));
|
|
assertEquals("hi_ZZ dvorak", "dvorak",
|
|
SubtypeLocaleUtils.getKeyboardLayoutSetName(HI_LATN_DVORAK));
|
|
}
|
|
if (SR_LATN != null) {
|
|
assertEquals("sr_ZZ", "serbian_qwertz",
|
|
SubtypeLocaleUtils.getKeyboardLayoutSetName(SR_LATN));
|
|
assertEquals("sr_ZZ qwerty", "qwerty",
|
|
SubtypeLocaleUtils.getKeyboardLayoutSetName(SR_LATN_QWERTY));
|
|
}
|
|
}
|
|
|
|
// InputMethodSubtype's display name in system locale (en_US).
|
|
// isAdditionalSubtype (T=true, F=false)
|
|
// locale layout | display name
|
|
// ------ -------------- - ----------------------
|
|
// en_US qwerty F English (US) exception
|
|
// en_GB qwerty F English (UK) exception
|
|
// es_US spanish F Spanish (US) exception
|
|
// fr azerty F French
|
|
// fr_CA qwerty F French (Canada)
|
|
// fr_CH swiss F French (Switzerland)
|
|
// de qwertz F German
|
|
// de_CH swiss F German (Switzerland)
|
|
// hi hindi F Hindi
|
|
// hi_ZZ qwerty F Hinglish exception
|
|
// sr south_slavic F Serbian
|
|
// sr_ZZ serbian_qwertz F Serbian (Latin) exception
|
|
// zz qwerty F Alphabet (QWERTY)
|
|
// fr qwertz T French (QWERTZ)
|
|
// de qwerty T German (QWERTY)
|
|
// en_US azerty T English (US) (AZERTY) exception
|
|
// en_UK dvorak T English (UK) (Dvorak) exception
|
|
// es_US colemak T Spanish (US) (Colemak) exception
|
|
// hi_ZZ dvorak T Hinglish (Dvorka) exception
|
|
// sr_ZZ qwerty T Serbian (QWERTY) exception
|
|
// zz pc T Alphabet (PC)
|
|
|
|
@Test
|
|
public void testPredefinedSubtypesInEnglishSystemLocale() {
|
|
final RunInLocale<Void> tests = new RunInLocale<Void>() {
|
|
@Override
|
|
protected Void job(final Resources res) {
|
|
assertEquals("en_US", "English (US)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(EN_US));
|
|
assertEquals("en_GB", "English (UK)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(EN_GB));
|
|
assertEquals("es_US", "Spanish (US)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(ES_US));
|
|
assertEquals("fr", "French",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(FR));
|
|
assertEquals("fr_CA", "French (Canada)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(FR_CA));
|
|
assertEquals("fr_CH", "French (Switzerland)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(FR_CH));
|
|
assertEquals("de", "German",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(DE));
|
|
assertEquals("de_CH", "German (Switzerland)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(DE_CH));
|
|
assertEquals("hi", "Hindi",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(HI));
|
|
assertEquals("sr", "Serbian",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(SR));
|
|
assertEquals("zz", "Alphabet (QWERTY)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(ZZ));
|
|
// These are preliminary subtypes and may not exist.
|
|
if (HI_LATN != null) {
|
|
assertEquals("hi_ZZ", "Hinglish",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(HI_LATN));
|
|
}
|
|
if (SR_LATN != null) {
|
|
assertEquals("sr_ZZ", "Serbian (Latin)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(SR_LATN));
|
|
}
|
|
return null;
|
|
}
|
|
};
|
|
tests.runInLocale(mRes, Locale.ENGLISH);
|
|
}
|
|
|
|
@Test
|
|
public void testAdditionalSubtypesInEnglishSystemLocale() {
|
|
final RunInLocale<Void> tests = new RunInLocale<Void>() {
|
|
@Override
|
|
protected Void job(final Resources res) {
|
|
assertEquals("fr qwertz", "French (QWERTZ)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(FR_QWERTZ));
|
|
assertEquals("de qwerty", "German (QWERTY)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(DE_QWERTY));
|
|
assertEquals("en_US azerty", "English (US) (AZERTY)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(EN_US_AZERTY));
|
|
assertEquals("en_UK dvorak","English (UK) (Dvorak)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(EN_UK_DVORAK));
|
|
assertEquals("es_US colemak", "Spanish (US) (Colemak)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(ES_US_COLEMAK));
|
|
assertEquals("zz azerty", "Alphabet (AZERTY)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(ZZ_AZERTY));
|
|
assertEquals("zz pc", "Alphabet (PC)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(ZZ_PC));
|
|
// These are preliminary subtypes and may not exist.
|
|
if (HI_LATN_DVORAK != null) {
|
|
assertEquals("hi_ZZ", "Hinglish (Dvorak)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(HI_LATN_DVORAK));
|
|
}
|
|
if (SR_LATN_QWERTY != null) {
|
|
assertEquals("sr_ZZ", "Serbian (QWERTY)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(SR_LATN_QWERTY));
|
|
}
|
|
return null;
|
|
}
|
|
};
|
|
tests.runInLocale(mRes, Locale.ENGLISH);
|
|
}
|
|
|
|
// InputMethodSubtype's display name in system locale (fr).
|
|
// isAdditionalSubtype (T=true, F=false)
|
|
// locale layout | display name
|
|
// ------ ------- - ----------------------
|
|
// en_US qwerty F Anglais (États-Unis) exception
|
|
// en_GB qwerty F Anglais (Royaume-Uni) exception
|
|
// es_US spanish F Espagnol (États-Unis) exception
|
|
// fr azerty F Français
|
|
// fr_CA qwerty F Français (Canada)
|
|
// fr_CH swiss F Français (Suisse)
|
|
// de qwertz F Allemand
|
|
// de_CH swiss F Allemand (Suisse)
|
|
// hi hindi F Hindi exception
|
|
// hi_ZZ qwerty F Hindi/Anglais exception
|
|
// sr south_slavic F Serbe exception
|
|
// sr_ZZ serbian_qwertz F Serbe (latin) exception
|
|
// zz qwerty F Alphabet latin (QWERTY)
|
|
// fr qwertz T Français (QWERTZ)
|
|
// de qwerty T Allemand (QWERTY)
|
|
// en_US azerty T Anglais (États-Unis) (AZERTY) exception
|
|
// en_UK dvorak T Anglais (Royaume-Uni) (Dvorak) exception
|
|
// es_US colemak T Espagnol (États-Unis) (Colemak) exception
|
|
// hi_ZZ dvorak T Hindi/Anglais (Dvorka) exception
|
|
// sr_ZZ qwerty T Serbe (QWERTY) exception
|
|
// zz pc T Alphabet latin (PC)
|
|
|
|
@Test
|
|
public void testPredefinedSubtypesInFrenchSystemLocale() {
|
|
final RunInLocale<Void> tests = new RunInLocale<Void>() {
|
|
@Override
|
|
protected Void job(final Resources res) {
|
|
assertEquals("en_US", "Anglais (États-Unis)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(EN_US));
|
|
assertEquals("en_GB", "Anglais (Royaume-Uni)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(EN_GB));
|
|
assertEquals("es_US", "Espagnol (États-Unis)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(ES_US));
|
|
assertEquals("fr", "Français",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(FR));
|
|
assertEquals("fr_CA", "Français (Canada)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(FR_CA));
|
|
assertEquals("fr_CH", "Français (Suisse)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(FR_CH));
|
|
assertEquals("de", "Allemand",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(DE));
|
|
assertEquals("de_CH", "Allemand (Suisse)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(DE_CH));
|
|
assertEquals("hi", "Hindi",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(HI));
|
|
assertEquals("sr", "Serbe",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(SR));
|
|
assertEquals("zz", "Alphabet latin (QWERTY)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(ZZ));
|
|
// These are preliminary subtypes and may not exist.
|
|
if (HI_LATN != null) {
|
|
assertEquals("hi_ZZ", "Hindi/Anglais",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(HI_LATN));
|
|
}
|
|
if (SR_LATN != null) {
|
|
assertEquals("sr_ZZ", "Serbe (latin)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(SR_LATN));
|
|
}
|
|
return null;
|
|
}
|
|
};
|
|
tests.runInLocale(mRes, Locale.FRENCH);
|
|
}
|
|
|
|
@Test
|
|
public void testAdditionalSubtypesInFrenchSystemLocale() {
|
|
final RunInLocale<Void> tests = new RunInLocale<Void>() {
|
|
@Override
|
|
protected Void job(final Resources res) {
|
|
assertEquals("fr qwertz", "Français (QWERTZ)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(FR_QWERTZ));
|
|
assertEquals("de qwerty", "Allemand (QWERTY)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(DE_QWERTY));
|
|
assertEquals("en_US azerty", "Anglais (États-Unis) (AZERTY)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(EN_US_AZERTY));
|
|
assertEquals("en_UK dvorak", "Anglais (Royaume-Uni) (Dvorak)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(EN_UK_DVORAK));
|
|
assertEquals("es_US colemak", "Espagnol (États-Unis) (Colemak)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(ES_US_COLEMAK));
|
|
assertEquals("zz azerty", "Alphabet latin (AZERTY)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(ZZ_AZERTY));
|
|
assertEquals("zz pc", "Alphabet latin (PC)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(ZZ_PC));
|
|
// These are preliminary subtypes and may not exist.
|
|
if (HI_LATN_DVORAK != null) {
|
|
assertEquals("hi_ZZ", "Hindi/Anglais (Dvorak)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(HI_LATN_DVORAK));
|
|
}
|
|
if (SR_LATN_QWERTY != null) {
|
|
assertEquals("sr_ZZ", "Serbe (QWERTY)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(SR_LATN_QWERTY));
|
|
}
|
|
return null;
|
|
}
|
|
};
|
|
tests.runInLocale(mRes, Locale.FRENCH);
|
|
}
|
|
|
|
// InputMethodSubtype's display name in system locale (hi).
|
|
// isAdditionalSubtype (T=true, F=false)
|
|
// locale layout | display name
|
|
// ------ ------- - ----------------------
|
|
// hi hindi F हिन्दी
|
|
// hi_ZZ qwerty F हिंग्लिश
|
|
// hi_ZZ dvorak T हिंग्लिश (Dvorak)
|
|
|
|
@Test
|
|
public void testHinglishSubtypesInHindiSystemLocale() {
|
|
final RunInLocale<Void> tests = new RunInLocale<Void>() {
|
|
@Override
|
|
protected Void job (final Resources res) {
|
|
assertEquals("hi", "हिन्दी",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(HI));
|
|
// These are preliminary subtypes and may not exist.
|
|
if (HI_LATN != null) {
|
|
assertEquals("hi_ZZ", "हिंग्लिश",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(HI_LATN));
|
|
assertEquals("hi_ZZ", "हिंग्लिश (Dvorak)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(HI_LATN_DVORAK));
|
|
}
|
|
return null;
|
|
}
|
|
};
|
|
tests.runInLocale(mRes, new Locale("hi"));
|
|
}
|
|
|
|
// InputMethodSubtype's display name in system locale (sr).
|
|
// isAdditionalSubtype (T=true, F=false)
|
|
// locale layout | display name
|
|
// ------ -------------- - ----------------------
|
|
// sr south_slavic F Српски
|
|
// sr_ZZ serbian_qwertz F Српски (латиница)
|
|
// sr_ZZ qwerty T Српски (QWERTY)
|
|
|
|
@Test
|
|
public void testSerbianLatinSubtypesInSerbianSystemLocale() {
|
|
final RunInLocale<Void> tests = new RunInLocale<Void>() {
|
|
@Override
|
|
protected Void job (final Resources res) {
|
|
assertEquals("sr", "Српски",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(SR));
|
|
// These are preliminary subtypes and may not exist.
|
|
if (SR_LATN != null) {
|
|
assertEquals("sr_ZZ", "Српски (латиница)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(SR_LATN));
|
|
assertEquals("sr_ZZ", "Српски (QWERTY)",
|
|
SubtypeLocaleUtils.getSubtypeDisplayNameInSystemLocale(SR_LATN_QWERTY));
|
|
}
|
|
return null;
|
|
}
|
|
};
|
|
tests.runInLocale(mRes, new Locale("sr"));
|
|
}
|
|
|
|
@Test
|
|
public void testIsRtlLanguage() {
|
|
// Known Right-to-Left language subtypes.
|
|
final InputMethodSubtype ARABIC = mRichImm
|
|
.findSubtypeByLocaleAndKeyboardLayoutSet("ar", "arabic");
|
|
assertNotNull("Arabic", ARABIC);
|
|
final InputMethodSubtype FARSI = mRichImm
|
|
.findSubtypeByLocaleAndKeyboardLayoutSet("fa", "farsi");
|
|
assertNotNull("Farsi", FARSI);
|
|
final InputMethodSubtype HEBREW = mRichImm
|
|
.findSubtypeByLocaleAndKeyboardLayoutSet("iw", "hebrew");
|
|
assertNotNull("Hebrew", HEBREW);
|
|
|
|
for (final RichInputMethodSubtype subtype : mSubtypesList) {
|
|
final InputMethodSubtype rawSubtype = subtype.getRawSubtype();
|
|
final String subtypeName = SubtypeLocaleUtils
|
|
.getSubtypeDisplayNameInSystemLocale(rawSubtype);
|
|
if (rawSubtype.equals(ARABIC) || rawSubtype.equals(FARSI)
|
|
|| rawSubtype.equals(HEBREW)) {
|
|
assertTrue(subtypeName, subtype.isRtlSubtype());
|
|
} else {
|
|
assertFalse(subtypeName, subtype.isRtlSubtype());
|
|
}
|
|
}
|
|
}
|
|
}
|