diff options
Diffstat (limited to 'tests/src')
9 files changed, 964 insertions, 653 deletions
diff --git a/tests/src/com/android/inputmethod/keyboard/internal/KeyStylesTests.java b/tests/src/com/android/inputmethod/keyboard/internal/KeyStylesTests.java index 4050a7123..29881d91c 100644 --- a/tests/src/com/android/inputmethod/keyboard/internal/KeyStylesTests.java +++ b/tests/src/com/android/inputmethod/keyboard/internal/KeyStylesTests.java @@ -16,30 +16,53 @@ package com.android.inputmethod.keyboard.internal; -import com.android.inputmethod.keyboard.internal.KeyStyles.EmptyKeyStyle; - +import android.content.res.Resources; import android.test.AndroidTestCase; import android.text.TextUtils; +import com.android.inputmethod.latin.tests.R; + +import java.util.Arrays; + public class KeyStylesTests extends AndroidTestCase { + private Resources mTestResources; + + @Override + protected void setUp() throws Exception { + super.setUp(); + + mTestResources = getTestContext().getResources(); + } + private static String format(String message, Object expected, Object actual) { return message + " expected:<" + expected + "> but was:<" + actual + ">"; } - private static void assertTextArray(String message, CharSequence value, - CharSequence ... expected) { - final CharSequence actual[] = EmptyKeyStyle.parseCsvText(value); + private void assertTextArray(String message, String value, String ... expected) { + final String actual[] = KeyStyles.parseCsvText(value, mTestResources, + R.string.empty_string); if (expected.length == 0) { assertNull(message, actual); return; } - assertSame(message + ": result length", expected.length, actual.length); + assertEquals(message + ": expected=" + Arrays.toString(expected) + + " actual=" + Arrays.toString(actual) + + ": result length", expected.length, actual.length); for (int i = 0; i < actual.length; i++) { final boolean equals = TextUtils.equals(expected[i], actual[i]); assertTrue(format(message + ": result at " + i + ":", expected[i], actual[i]), equals); } } + private void assertError(String message, String value, String ... expected) { + try { + assertTextArray(message, value, expected); + fail(message); + } catch (Exception pcpe) { + // success. + } + } + public void testParseCsvTextZero() { assertTextArray("Empty string", ""); } @@ -52,7 +75,10 @@ public class KeyStylesTests extends AndroidTestCase { assertTextArray("Spaces in label", "a b c", "a b c"); assertTextArray("Spaces at beginning of label", " abc", " abc"); assertTextArray("Spaces at end of label", "abc ", "abc "); - assertTextArray("label surrounded by spaces", " abc ", " abc "); + assertTextArray("Label surrounded by spaces", " abc ", " abc "); + + assertTextArray("Incomplete resource reference 1", "string", "string"); + assertTextArray("Incomplete resource reference 2", "@strin", "@strin"); } public void testParseCsvTextSingleEscaped() { @@ -60,11 +86,13 @@ public class KeyStylesTests extends AndroidTestCase { assertTextArray("Escaped comma", "\\,", ","); assertTextArray("Escaped escape", "\\\\", "\\"); assertTextArray("Escaped label", "a\\bc", "abc"); - assertTextArray("Escaped label at begininng", "\\abc", "abc"); + assertTextArray("Escaped label at beginning", "\\abc", "abc"); assertTextArray("Escaped label with comma", "a\\,c", "a,c"); assertTextArray("Escaped label with comma at beginning", "\\,bc", ",bc"); assertTextArray("Escaped label with successive", "\\,\\\\bc", ",\\bc"); assertTextArray("Escaped label with escape", "a\\\\c", "a\\c"); + + assertTextArray("Escaped @string", "\\@string/empty_string", "@string/empty_string"); } public void testParseCsvTextMulti() { @@ -86,5 +114,109 @@ public class KeyStylesTests extends AndroidTestCase { "ab\\\\,d\\\\\\,,g\\,i", "ab\\", "d\\,", "g,i"); assertTextArray("Multiple labels with comma and escape surrounded by spaces", " ab\\\\ , d\\\\\\, , g\\,i ", " ab\\ ", " d\\, ", " g,i "); + + assertTextArray("Multiple escaped @string", "\\@,\\@string/empty_string", + "@", "@string/empty_string"); + } + + public void testParseCsvResourceError() { + assertError("Incomplete resource name 1", "@string", "@string"); + assertError("Incomplete resource name 2", "@string/", "@string/"); + assertError("Non existing resource", "@string/non_existing"); + } + + public void testParseCsvResourceZero() { + assertTextArray("Empty string", + "@string/empty_string"); + } + + public void testParseCsvResourceSingle() { + assertTextArray("Single char", + "@string/single_char", "a"); + assertTextArray("Space", + "@string/space", " "); + assertTextArray("Single label", + "@string/single_label", "abc"); + assertTextArray("Spaces", + "@string/spaces", " "); + assertTextArray("Spaces in label", + "@string/spaces_in_label", "a b c"); + assertTextArray("Spaces at beginning of label", + "@string/spaces_at_beginning_of_label", " abc"); + assertTextArray("Spaces at end of label", + "@string/spaces_at_end_of_label", "abc "); + assertTextArray("label surrounded by spaces", + "@string/label_surrounded_by_spaces", " abc "); + } + + public void testParseCsvResourceSingleEscaped() { + assertTextArray("Escaped char", + "@string/escaped_char", "a"); + assertTextArray("Escaped comma", + "@string/escaped_comma", ","); + assertTextArray("Escaped escape", + "@string/escaped_escape", "\\"); + assertTextArray("Escaped label", + "@string/escaped_label", "abc"); + assertTextArray("Escaped label at beginning", + "@string/escaped_label_at_beginning", "abc"); + assertTextArray("Escaped label with comma", + "@string/escaped_label_with_comma", "a,c"); + assertTextArray("Escaped label with comma at beginning", + "@string/escaped_label_with_comma_at_beginning", ",bc"); + assertTextArray("Escaped label with successive", + "@string/escaped_label_with_successive", ",\\bc"); + assertTextArray("Escaped label with escape", + "@string/escaped_label_with_escape", "a\\c"); + } + + public void testParseCsvResourceMulti() { + assertTextArray("Multiple chars", + "@string/multiple_chars", "a", "b", "c"); + assertTextArray("Multiple chars surrounded by spaces", + "@string/multiple_chars_surrounded_by_spaces", + " a ", " b ", " c "); + assertTextArray("Multiple labels", + "@string/multiple_labels", "abc", "def", "ghi"); + assertTextArray("Multiple labels surrounded by spaces", + "@string/multiple_labels_surrounded_by_spaces", " abc ", " def ", " ghi "); + } + + public void testParseCsvResourcetMultiEscaped() { + assertTextArray("Multiple chars with comma", + "@string/multiple_chars_with_comma", + "a", ",", "c"); + assertTextArray("Multiple chars with comma surrounded by spaces", + "@string/multiple_chars_with_comma_surrounded_by_spaces", + " a ", " , ", " c "); + assertTextArray("Multiple labels with escape", + "@string/multiple_labels_with_escape", + "abc", "def", "ghi"); + assertTextArray("Multiple labels with escape surrounded by spaces", + "@string/multiple_labels_with_escape_surrounded_by_spaces", + " abc ", " def ", " ghi "); + assertTextArray("Multiple labels with comma and escape", + "@string/multiple_labels_with_comma_and_escape", + "ab\\", "d\\,", "g,i"); + assertTextArray("Multiple labels with comma and escape surrounded by spaces", + "@string/multiple_labels_with_comma_and_escape_surrounded_by_spaces", + " ab\\ ", " d\\, ", " g,i "); + } + + public void testParseMultipleResources() { + assertTextArray("Literals and resources", + "1,@string/multiple_chars,z", "1", "a", "b", "c", "z"); + assertTextArray("Multiple single resource chars and labels", + "@string/single_char,@string/single_label,@string/escaped_comma", + "a", "abc", ","); + assertTextArray("Multiple multiple resource chars and labels", + "@string/multiple_chars,@string/multiple_labels,@string/multiple_chars_with_comma", + "a", "b", "c", "abc", "def", "ghi", "a", ",", "c"); + assertTextArray("Concatenated resources", + "@string/multiple_chars@string/multiple_labels@string/multiple_chars_with_comma", + "a", "b", "cabc", "def", "ghia", ",", "c"); + assertTextArray("Concatenated resource and literal", + "abc@string/multiple_labels", + "abcabc", "def", "ghi"); } } diff --git a/tests/src/com/android/inputmethod/keyboard/internal/KeyboardStateMultiTouchTests.java b/tests/src/com/android/inputmethod/keyboard/internal/KeyboardStateMultiTouchTests.java new file mode 100644 index 000000000..729120bba --- /dev/null +++ b/tests/src/com/android/inputmethod/keyboard/internal/KeyboardStateMultiTouchTests.java @@ -0,0 +1,162 @@ +/* + * Copyright (C) 2012 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.keyboard.internal; + +public class KeyboardStateMultiTouchTests extends KeyboardStateTestsBase { + // Shift key chording input. + public void testChording() { + // Press shift key and hold, enter into choring shift state. + pressKey(CODE_SHIFT, ALPHABET_MANUAL_SHIFTED); + + // Press/release letter keys. + chordingPressAndReleaseKey('Z', ALPHABET_MANUAL_SHIFTED, ALPHABET_MANUAL_SHIFTED); + chordingPressAndReleaseKey('X', ALPHABET_MANUAL_SHIFTED, ALPHABET_MANUAL_SHIFTED); + + // Release shift key, switch back to alphabet. + releaseKey(CODE_SHIFT, ALPHABET_UNSHIFTED); + + // Press symbols key and hold, enter into choring symbols state. + pressKey(CODE_SYMBOL, SYMBOLS_UNSHIFTED); + + // Press/release symbol letter keys. + chordingPressAndReleaseKey('1', SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + chordingPressAndReleaseKey('2', SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + + // Release symbols key, switch back to alphabet. + releaseKey(CODE_SYMBOL, ALPHABET_UNSHIFTED); + } + + // Shift key chording input in shift locked. + public void testShiftChordingShiftLocked() { + // Long press shift key, enter alphabet shift locked. + longPressShiftKey(ALPHABET_MANUAL_SHIFTED, ALPHABET_SHIFT_LOCKED); + + // Press shift key and hold, enter into choring shift state. + pressKey(CODE_SHIFT, ALPHABET_MANUAL_SHIFTED); + + // Press/release letter keys. + chordingPressAndReleaseKey('Z', ALPHABET_MANUAL_SHIFTED, ALPHABET_MANUAL_SHIFTED); + chordingPressAndReleaseKey('X', ALPHABET_MANUAL_SHIFTED, ALPHABET_MANUAL_SHIFTED); + + // Release shift key, switch back to alphabet shift locked. + releaseKey(CODE_SHIFT, ALPHABET_SHIFT_LOCKED); + + // Press symbols key and hold, enter into choring symbols state. + pressKey(CODE_SYMBOL, SYMBOLS_UNSHIFTED); + + // Press/release symbol letter keys. + chordingPressAndReleaseKey('1', SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + chordingPressAndReleaseKey('2', SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + + // Release symbols key, switch back to alphabet shift locked. + releaseKey(CODE_SYMBOL, ALPHABET_SHIFT_LOCKED); + } + + // Symbols key chording input. + public void testSymbolsChording() { + // Press/release symbols key, enter symbols. + pressAndReleaseKey(CODE_SYMBOL, SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + + // Press shift key and hold, enter into choring symbols shifted state. + pressKey(CODE_SHIFT, SYMBOLS_SHIFTED); + + // Press/release symbols keys. + chordingPressAndReleaseKey('1', SYMBOLS_SHIFTED, SYMBOLS_SHIFTED); + chordingPressAndReleaseKey('2', SYMBOLS_SHIFTED, SYMBOLS_SHIFTED); + + // Release shift key, switch back to symbols. + releaseKey(CODE_SHIFT, SYMBOLS_UNSHIFTED); + + // Press "ABC" key and hold, enter into choring alphabet state. + pressKey(CODE_SYMBOL, ALPHABET_UNSHIFTED); + + // Press/release letter keys. + chordingPressAndReleaseKey('a', ALPHABET_UNSHIFTED, ALPHABET_UNSHIFTED); + chordingPressAndReleaseKey('b', ALPHABET_UNSHIFTED, ALPHABET_UNSHIFTED); + + // Release "ABC" key, switch back to symbols. + releaseKey(CODE_SYMBOL, SYMBOLS_UNSHIFTED); + } + + // Symbols shifted key chording input in symbol. + public void testSymbolsShiftedChording() { + // Press/release symbols key, enter symbols. + pressAndReleaseKey(CODE_SYMBOL, SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + // Press/release shift key, enter symbols shifted. + pressAndReleaseKey(CODE_SHIFT, SYMBOLS_SHIFTED, SYMBOLS_SHIFTED); + + // Press shift key and hold, enter into chording symbols state. + pressKey(CODE_SHIFT, SYMBOLS_UNSHIFTED); + + // Press/release symbol letter keys. + chordingPressAndReleaseKey('1', SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + chordingPressAndReleaseKey('2', SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + + // Release shift key, switch back to symbols shifted state. + releaseKey(CODE_SHIFT, SYMBOLS_SHIFTED); + + // Press "ABC" key and hold, enter into choring alphabet state. + pressKey(CODE_SYMBOL, ALPHABET_UNSHIFTED); + + // Press/release letter keys. + chordingPressAndReleaseKey('a', ALPHABET_UNSHIFTED, ALPHABET_UNSHIFTED); + chordingPressAndReleaseKey('b', ALPHABET_UNSHIFTED, ALPHABET_UNSHIFTED); + + // Release "ABC" key, switch back to symbols. + releaseKey(CODE_SYMBOL, SYMBOLS_SHIFTED); + } + + // Chording shift key in automatic upper case. + public void testAutomaticUpperCaseChording() { + // Set auto caps mode on. + setAutoCapsMode(AUTO_CAPS); + + // Update shift state with auto caps enabled. + updateShiftState(ALPHABET_AUTOMATIC_SHIFTED); + + // Press shift key and hold, enter into chording shift state. + pressKey(CODE_SHIFT, ALPHABET_MANUAL_SHIFTED); + + // Press/release letter keys. + chordingPressAndReleaseKey('Z', ALPHABET_MANUAL_SHIFTED, ALPHABET_MANUAL_SHIFTED); + + // Release shift key, switch back to alphabet. + releaseKey(CODE_SHIFT, ALPHABET_UNSHIFTED); + } + + // Chording symbol key in automatic upper case. + public void testAutomaticUpperCaseChording2() { + // Set auto caps mode on. + setAutoCapsMode(AUTO_CAPS); + + // Update shift state with auto caps enabled. + updateShiftState(ALPHABET_AUTOMATIC_SHIFTED); + + // Press "123?" key and hold, enter into chording symbols state. + pressKey(CODE_SYMBOL, SYMBOLS_UNSHIFTED); + + // Press/release symbol letter keys. + chordingPressAndReleaseKey('1', SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + + // Release "123?" key, switch back to alphabet. + releaseKey(CODE_SYMBOL, ALPHABET_UNSHIFTED); + } + + // TODO: Multitouch test + + // TODO: n-Keys roll over test +} diff --git a/tests/src/com/android/inputmethod/keyboard/internal/KeyboardStateNonDistinctTests.java b/tests/src/com/android/inputmethod/keyboard/internal/KeyboardStateNonDistinctTests.java deleted file mode 100644 index e3f0e0718..000000000 --- a/tests/src/com/android/inputmethod/keyboard/internal/KeyboardStateNonDistinctTests.java +++ /dev/null @@ -1,430 +0,0 @@ -/* - * Copyright (C) 2012 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.keyboard.internal; - -import android.test.AndroidTestCase; - -public class KeyboardStateNonDistinctTests extends AndroidTestCase - implements MockKeyboardSwitcher.Constants { - protected MockKeyboardSwitcher mSwitcher; - - public boolean hasDistinctMultitouch() { - return false; - } - - @Override - protected void setUp() throws Exception { - super.setUp(); - - mSwitcher = new MockKeyboardSwitcher(); - - final String layoutSwitchBackSymbols = ""; - mSwitcher.loadKeyboard(layoutSwitchBackSymbols, hasDistinctMultitouch()); - } - - public void assertAlphabetNormal() { - assertTrue(mSwitcher.assertAlphabetNormal()); - } - - public void assertAlphabetManualShifted() { - assertTrue(mSwitcher.assertAlphabetManualShifted()); - } - - public void assertAlphabetAutomaticShifted() { - assertTrue(mSwitcher.assertAlphabetAutomaticShifted()); - } - - public void assertAlphabetShiftLocked() { - assertTrue(mSwitcher.assertAlphabetShiftLocked()); - } - - public void assertSymbolsNormal() { - assertTrue(mSwitcher.assertSymbolsNormal()); - } - - public void assertSymbolsShifted() { - assertTrue(mSwitcher.assertSymbolsShifted()); - } - - // Initial state test. - public void testLoadKeyboard() { - assertAlphabetNormal(); - } - - // Shift key in alphabet mode. - public void testShift() { - // Press/release shift key, enter into shift state. - mSwitcher.onPressKey(CODE_SHIFT); - assertAlphabetManualShifted(); - mSwitcher.onCodeInput(CODE_SHIFT); - mSwitcher.onReleaseKey(CODE_SHIFT); - assertAlphabetManualShifted(); - // Press/release shift key, back to normal state. - mSwitcher.onPressKey(CODE_SHIFT); - assertAlphabetManualShifted(); - mSwitcher.onCodeInput(CODE_SHIFT); - mSwitcher.onReleaseKey(CODE_SHIFT); - assertAlphabetNormal(); - - // Press/release shift key, enter into shift state. - mSwitcher.onPressKey(CODE_SHIFT); - assertAlphabetManualShifted(); - mSwitcher.onCodeInput(CODE_SHIFT); - mSwitcher.onReleaseKey(CODE_SHIFT); - assertAlphabetManualShifted(); - // Press/release letter key, snap back to normal state. - mSwitcher.onPressKey('Z'); - mSwitcher.onCodeInput('Z'); - mSwitcher.onReleaseKey('Z'); - assertAlphabetNormal(); - } - - // Shift key sliding input. - public void testShiftSliding() { - // Press shift key. - mSwitcher.onPressKey(CODE_SHIFT); - assertAlphabetManualShifted(); - // Slide out shift key. - mSwitcher.onReleaseKey(CODE_SHIFT, SLIDING); - assertAlphabetManualShifted(); - - // Enter into letter key. - mSwitcher.onPressKey('Z'); - assertAlphabetManualShifted(); - // Release letter key, snap back to alphabet. - mSwitcher.onCodeInput('Z'); - mSwitcher.onReleaseKey('Z'); - assertAlphabetNormal(); - } - - public void enterSymbolsMode() { - // Press/release "?123" key. - mSwitcher.onPressKey(CODE_SYMBOL); - assertSymbolsNormal(); - mSwitcher.onCodeInput(CODE_SYMBOL); - mSwitcher.onReleaseKey(CODE_SYMBOL); - assertSymbolsNormal(); - } - - public void leaveSymbolsMode() { - // Press/release "ABC" key. - mSwitcher.onPressKey(CODE_SYMBOL); - assertAlphabetNormal(); - mSwitcher.onCodeInput(CODE_SYMBOL); - mSwitcher.onReleaseKey(CODE_SYMBOL); - assertAlphabetNormal(); - } - - // Switching between alphabet and symbols. - public void testAlphabetAndSymbols() { - enterSymbolsMode(); - leaveSymbolsMode(); - } - - // Switching between alphabet shift locked and symbols. - public void testAlphabetShiftLockedAndSymbols() { - enterShiftLockWithLongPressShift(); - enterSymbolsMode(); - - // Press/release "ABC" key, switch back to shift locked mode. - mSwitcher.onPressKey(CODE_SYMBOL); - assertAlphabetShiftLocked(); - mSwitcher.onCodeInput(CODE_SYMBOL); - mSwitcher.onReleaseKey(CODE_SYMBOL); - assertAlphabetShiftLocked(); - } - - // Symbols key sliding input. - public void testSymbolsSliding() { - // Press "123?" key. - mSwitcher.onPressKey(CODE_SYMBOL); - assertSymbolsNormal(); - // Slide out from "123?" key. - mSwitcher.onReleaseKey(CODE_SYMBOL, SLIDING); - assertSymbolsNormal(); - - // Enter into letter key. - mSwitcher.onPressKey('z'); - assertSymbolsNormal(); - // Release letter key, snap back to alphabet. - mSwitcher.onCodeInput('z'); - mSwitcher.onReleaseKey('z'); - assertAlphabetNormal(); - } - - // Switching between symbols and symbols shifted. - public void testSymbolsAndSymbolsShifted() { - enterSymbolsMode(); - - // Press/release "=\<" key. - mSwitcher.onPressKey(CODE_SHIFT); - assertSymbolsShifted(); - mSwitcher.onCodeInput(CODE_SHIFT); - mSwitcher.onReleaseKey(CODE_SHIFT); - assertSymbolsShifted(); - - // Press/release "?123" key. - mSwitcher.onPressKey(CODE_SHIFT); - assertSymbolsNormal(); - mSwitcher.onCodeInput(CODE_SHIFT); - mSwitcher.onReleaseKey(CODE_SHIFT); - assertSymbolsNormal(); - - leaveSymbolsMode(); - } - - // Symbols shift sliding input - public void testSymbolsShiftSliding() { - enterSymbolsMode(); - - // Press "=\<" key. - mSwitcher.onPressKey(CODE_SHIFT); - assertSymbolsShifted(); - // Slide out "=\<" key. - mSwitcher.onReleaseKey(CODE_SHIFT, SLIDING); - assertSymbolsShifted(); - - // Enter into symbol shifted letter key. - mSwitcher.onPressKey('~'); - assertSymbolsShifted(); - // Release symbol shifted letter key, snap back to symbols. - mSwitcher.onCodeInput('~'); - mSwitcher.onReleaseKey('~'); - assertSymbolsNormal(); - } - - // Symbols shift sliding input from symbols shifted. - public void testSymbolsShiftSliding2() { - enterSymbolsMode(); - - // Press/release "=\<" key. - mSwitcher.onPressKey(CODE_SHIFT); - assertSymbolsShifted(); - mSwitcher.onCodeInput(CODE_SHIFT); - mSwitcher.onReleaseKey(CODE_SHIFT); - assertSymbolsShifted(); - - // Press "123?" key. - mSwitcher.onPressKey(CODE_SHIFT); - assertSymbolsNormal(); - // Slide out "123?" key. - mSwitcher.onReleaseKey(CODE_SHIFT, SLIDING); - assertSymbolsNormal(); - - // Enter into symbol letter key. - mSwitcher.onPressKey('1'); - assertSymbolsNormal(); - // Release symbol letter key, snap back to symbols shift. - mSwitcher.onCodeInput('1'); - mSwitcher.onReleaseKey('1'); - assertSymbolsShifted(); - } - - // Automatic snap back to alphabet from symbols by space key. - public void testSnapBackBySpace() { - enterSymbolsMode(); - - // Enter a symbol letter. - mSwitcher.onPressKey('1'); - assertSymbolsNormal(); - mSwitcher.onCodeInput('1'); - mSwitcher.onReleaseKey('1'); - assertSymbolsNormal(); - // Enter space, snap back to alphabet. - mSwitcher.onPressKey(CODE_SPACE); - assertSymbolsNormal(); - mSwitcher.onCodeInput(CODE_SPACE); - mSwitcher.onReleaseKey(CODE_SPACE); - assertAlphabetNormal(); - } - - // TODO: Add automatic snap back to shift locked test. - - // Automatic snap back to alphabet from symbols by registered letters. - public void testSnapBack() { - final String snapBackChars = "'"; - final int snapBackCode = snapBackChars.codePointAt(0); - final boolean hasDistinctMultitouch = true; - mSwitcher.loadKeyboard(snapBackChars, hasDistinctMultitouch); - - enterSymbolsMode(); - - // Enter a symbol letter. - mSwitcher.onPressKey('1'); - assertSymbolsNormal(); - mSwitcher.onCodeInput('1'); - mSwitcher.onReleaseKey('1'); - assertSymbolsNormal(); - // Enter snap back letter, snap back to alphabet. - mSwitcher.onPressKey(snapBackCode); - assertSymbolsNormal(); - mSwitcher.onCodeInput(snapBackCode); - mSwitcher.onReleaseKey(snapBackCode); - assertAlphabetNormal(); - } - - // Automatic upper case test - public void testAutomaticUpperCase() { - mSwitcher.setAutoCapsMode(AUTO_CAPS); - // Update shift state with auto caps enabled. - mSwitcher.updateShiftState(); - assertAlphabetAutomaticShifted(); - - // Press shift key. - mSwitcher.onPressKey(CODE_SHIFT); - assertAlphabetManualShifted(); - // Release shift key. - mSwitcher.onCodeInput(CODE_SHIFT); - mSwitcher.onReleaseKey(CODE_SHIFT); - assertAlphabetNormal(); - } - - // Sliding from shift key in automatic upper case. - public void testAutomaticUpperCaseSliding() { - mSwitcher.setAutoCapsMode(AUTO_CAPS); - // Update shift state with auto caps enabled. - mSwitcher.updateShiftState(); - assertAlphabetAutomaticShifted(); - - // Press shift key. - mSwitcher.onPressKey(CODE_SHIFT); - assertAlphabetManualShifted(); - // Slide out shift key. - mSwitcher.onReleaseKey(CODE_SHIFT, SLIDING); - assertAlphabetManualShifted(); - // Enter into letter key. - mSwitcher.onPressKey('Z'); - assertAlphabetManualShifted(); - // Release letter key, snap back to alphabet. - mSwitcher.onCodeInput('Z'); - mSwitcher.onReleaseKey('Z'); - assertAlphabetNormal(); - } - - // Sliding from symbol key in automatic upper case. - public void testAutomaticUpperCaseSliding2() { - mSwitcher.setAutoCapsMode(AUTO_CAPS); - // Update shift state with auto caps enabled. - mSwitcher.updateShiftState(); - assertAlphabetAutomaticShifted(); - - // Press "123?" key. - mSwitcher.onPressKey(CODE_SYMBOL); - assertSymbolsNormal(); - // Slide out "123?" key. - mSwitcher.onReleaseKey(CODE_SYMBOL, SLIDING); - assertSymbolsNormal(); - // Enter into symbol letter keys. - mSwitcher.onPressKey('1'); - assertSymbolsNormal(); - // Release symbol letter key, snap back to alphabet. - mSwitcher.onCodeInput('1'); - mSwitcher.onReleaseKey('1'); - assertAlphabetNormal(); - } - - public void enterShiftLockWithLongPressShift() { - // Long press shift key - mSwitcher.onPressKey(CODE_SHIFT); - assertAlphabetManualShifted(); - // Long press recognized in LatinKeyboardView.KeyTimerHandler. - mSwitcher.onCodeInput(CODE_CAPSLOCK); - assertAlphabetShiftLocked(); - mSwitcher.onReleaseKey(CODE_SHIFT); - assertAlphabetShiftLocked(); - } - - public void leaveShiftLockWithLongPressShift() { - // Press shift key. - mSwitcher.onPressKey(CODE_SHIFT); - assertAlphabetManualShifted(); - // Long press recognized in LatinKeyboardView.KeyTimerHandler. - mSwitcher.onCodeInput(CODE_CAPSLOCK); - assertAlphabetNormal(); - mSwitcher.onReleaseKey(CODE_SHIFT); - assertAlphabetNormal(); - } - - // Long press shift key. - // TODO: Move long press recognizing timer/logic into KeyboardState. - public void testLongPressShift() { - enterShiftLockWithLongPressShift(); - leaveShiftLockWithLongPressShift(); - } - - // Leave shift lock with single tap shift key. - public void testShiftInShiftLock() { - enterShiftLockWithLongPressShift(); - assertAlphabetShiftLocked(); - - // Tap shift key. - mSwitcher.onPressKey(CODE_SHIFT); - assertAlphabetManualShifted(); - mSwitcher.onCodeInput(CODE_SHIFT, SINGLE); - assertAlphabetManualShifted(); - mSwitcher.onReleaseKey(CODE_SHIFT); - assertAlphabetNormal(); - } - - // Double tap shift key. - // TODO: Move double tap recognizing timer/logic into KeyboardState. - public void testDoubleTapShift() { - // First shift key tap. - mSwitcher.onPressKey(CODE_SHIFT); - assertAlphabetManualShifted(); - mSwitcher.onCodeInput(CODE_SHIFT); - assertAlphabetManualShifted(); - mSwitcher.onReleaseKey(CODE_SHIFT); - assertAlphabetManualShifted(); - // Second shift key tap. - // Double tap recognized in LatinKeyboardView.KeyTimerHandler. - mSwitcher.onCodeInput(CODE_CAPSLOCK); - assertAlphabetShiftLocked(); - - // First shift key tap. - mSwitcher.onPressKey(CODE_SHIFT); - assertAlphabetManualShifted(); - mSwitcher.onCodeInput(CODE_SHIFT); - assertAlphabetManualShifted(); - mSwitcher.onReleaseKey(CODE_SHIFT); - assertAlphabetNormal(); - // Second shift key tap. - // Second tap is ignored in LatinKeyboardView.KeyTimerHandler. - } - - // Update shift state. - public void testUpdateShiftState() { - mSwitcher.setAutoCapsMode(AUTO_CAPS); - // Update shift state. - mSwitcher.updateShiftState(); - assertAlphabetAutomaticShifted(); - } - - // Update shift state when shift locked. - public void testUpdateShiftStateInShiftLocked() { - mSwitcher.setAutoCapsMode(AUTO_CAPS); - enterShiftLockWithLongPressShift(); - assertAlphabetShiftLocked(); - // Update shift state when shift locked - mSwitcher.updateShiftState(); - assertAlphabetShiftLocked(); - } - - // TODO: Change focus test. - - // TODO: Change orientation test. -} diff --git a/tests/src/com/android/inputmethod/keyboard/internal/KeyboardStateSingleTouchTests.java b/tests/src/com/android/inputmethod/keyboard/internal/KeyboardStateSingleTouchTests.java new file mode 100644 index 000000000..d13ca632a --- /dev/null +++ b/tests/src/com/android/inputmethod/keyboard/internal/KeyboardStateSingleTouchTests.java @@ -0,0 +1,353 @@ +/* + * Copyright (C) 2012 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.keyboard.internal; + +public class KeyboardStateSingleTouchTests extends KeyboardStateTestsBase { + // Shift key in alphabet mode. + public void testShift() { + // Press/release shift key, enter into shift state. + pressAndReleaseKey(CODE_SHIFT, ALPHABET_MANUAL_SHIFTED, ALPHABET_MANUAL_SHIFTED); + // Press/release shift key, back to normal state. + pressAndReleaseKey(CODE_SHIFT, ALPHABET_MANUAL_SHIFTED, ALPHABET_UNSHIFTED); + + // Press/release shift key, enter into shift state. + pressAndReleaseKey(CODE_SHIFT, ALPHABET_MANUAL_SHIFTED, ALPHABET_MANUAL_SHIFTED); + // Press/release letter key, switch back to normal state. + pressAndReleaseKey('Z', ALPHABET_MANUAL_SHIFTED, ALPHABET_UNSHIFTED); + } + + // Shift key sliding input. + public void testShiftSliding() { + // Press and slide from shift key. + pressAndSlideFromKey(CODE_SHIFT, ALPHABET_MANUAL_SHIFTED, ALPHABET_MANUAL_SHIFTED); + + // Enter/release letter key, switch back to alphabet. + pressAndReleaseKey('Z', ALPHABET_MANUAL_SHIFTED, ALPHABET_UNSHIFTED); + } + + // Switching between alphabet and symbols. + public void testAlphabetAndSymbols() { + // Press/release "?123" key, enter into symbols. + pressAndReleaseKey(CODE_SYMBOL, SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + // Press/release "?123" key, back to alphabet. + pressAndReleaseKey(CODE_SYMBOL, ALPHABET_UNSHIFTED, ALPHABET_UNSHIFTED); + } + + // Switching between alphabet shift locked and symbols. + public void testAlphabetShiftLockedAndSymbols() { + // Long press shift key, enter alphabet shift locked. + longPressShiftKey(ALPHABET_MANUAL_SHIFTED, ALPHABET_SHIFT_LOCKED); + + // Press/release "?123" key, enter into symbols. + pressAndReleaseKey(CODE_SYMBOL, SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + + // Press/release "ABC" key, switch back to shift locked mode. + pressAndReleaseKey(CODE_SYMBOL, ALPHABET_SHIFT_LOCKED, ALPHABET_SHIFT_LOCKED); + } + + // Symbols key sliding input. + public void testSymbolsSliding() { + // Press and slide from "123?" key. + pressAndSlideFromKey(CODE_SYMBOL, SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + + // Enter/release into symbol key, switch back to alphabet. + pressAndReleaseKey('!', SYMBOLS_UNSHIFTED, ALPHABET_UNSHIFTED); + } + + // Switching between symbols and symbols shifted. + public void testSymbolsAndSymbolsShifted() { + // Press/release "?123" key, enter into symbols. + pressAndReleaseKey(CODE_SYMBOL, SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + + // Press/release "=\<" key, enter into symbols shifted. + pressAndReleaseKey(CODE_SHIFT, SYMBOLS_SHIFTED, SYMBOLS_SHIFTED); + + // Press/release "?123" key, enter into symbols. + pressAndReleaseKey(CODE_SHIFT, SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + } + + // Symbols shift sliding input + public void testSymbolsShiftSliding() { + // Press/release "?123" key, enter into symbols. + pressAndReleaseKey(CODE_SYMBOL, SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + + // Press and slide from "=\<" key. + pressAndSlideFromKey(CODE_SHIFT, SYMBOLS_SHIFTED, SYMBOLS_SHIFTED); + + // Enter/release symbol shifted letter key, switch back to symbols. + pressAndReleaseKey('~', SYMBOLS_SHIFTED, SYMBOLS_UNSHIFTED); + } + + // Symbols shift sliding input from symbols shifted. + public void testSymbolsShiftSliding2() { + // Press/release "?123" key, enter into symbols. + pressAndReleaseKey(CODE_SYMBOL, SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + + // Press/release "=\<" key, enter into symbols shifted. + pressAndReleaseKey(CODE_SHIFT, SYMBOLS_SHIFTED, SYMBOLS_SHIFTED); + + // Press and slide from "123?" key. + pressAndSlideFromKey(CODE_SHIFT, SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + + // Enter/release symbol letter key, switch back to symbols shifted. + pressAndReleaseKey('1', SYMBOLS_UNSHIFTED, SYMBOLS_SHIFTED); + } + + // Automatic switch back to alphabet from symbols by space key. + public void testSwitchBackBySpace() { + // Press/release "?123" key, enter into symbols. + pressAndReleaseKey(CODE_SYMBOL, SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + + // Enter a symbol letter. + pressAndReleaseKey('1', SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + + // Enter space, switch back to alphabet. + pressAndReleaseKey(CODE_SPACE, SYMBOLS_UNSHIFTED, ALPHABET_UNSHIFTED); + } + + // Automatic switch back to shift locked test. + public void testSwitchBackBySpaceInShiftLocked() { + // Long press shift key, enter alphabet shift locked. + longPressShiftKey(ALPHABET_MANUAL_SHIFTED, ALPHABET_SHIFT_LOCKED); + + // Press/release "?123" key, enter into symbols. + pressAndReleaseKey(CODE_SYMBOL, SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + + // Enter a symbol letter. + pressAndReleaseKey('1', SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + + // Enter space, switch back to alphabet. + pressAndReleaseKey(CODE_SPACE, SYMBOLS_UNSHIFTED, ALPHABET_SHIFT_LOCKED); + } + + + // Automatic switch back to alphabet from symbols by registered letters. + public void testSwitchBackChar() { + // Set switch back chars. + final String switchBackSymbols = "'"; + final int switchBackCode = switchBackSymbols.codePointAt(0); + setLayoutSwitchBackSymbols(switchBackSymbols); + loadKeyboard(ALPHABET_UNSHIFTED); + + // Press/release "?123" key, enter into symbols. + pressAndReleaseKey(CODE_SYMBOL, SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + + // Enter a symbol letter. + pressAndReleaseKey('1', SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + + // Enter switch back letter, switch back to alphabet. + pressAndReleaseKey(switchBackCode, SYMBOLS_UNSHIFTED, ALPHABET_UNSHIFTED); + } + + // Automatic upper case test + public void testAutomaticUpperCase() { + // Set auto caps mode on. + setAutoCapsMode(AUTO_CAPS); + + // Update shift state with auto caps enabled. + updateShiftState(ALPHABET_AUTOMATIC_SHIFTED); + + // Press/release shift key, back to alphabet. + pressAndReleaseKey(CODE_SHIFT, ALPHABET_MANUAL_SHIFTED, ALPHABET_UNSHIFTED); + } + + // Sliding from shift key in automatic upper case. + public void testAutomaticUpperCaseSliding() { + // Set auto caps mode on. + setAutoCapsMode(AUTO_CAPS); + + // Update shift state with auto caps enabled. + updateShiftState(ALPHABET_AUTOMATIC_SHIFTED); + + // Press and slide from shift key. + pressAndSlideFromKey(CODE_SHIFT, ALPHABET_MANUAL_SHIFTED, ALPHABET_MANUAL_SHIFTED); + + // Enter and release letter key, back to alphabet. + pressAndReleaseKey('Z', ALPHABET_MANUAL_SHIFTED, ALPHABET_UNSHIFTED); + } + + // Sliding from symbol key in automatic upper case. + public void testAutomaticUpperCaseSliding2() { + // Set auto caps mode on. + setAutoCapsMode(AUTO_CAPS); + + // Update shift state with auto caps enabled. + updateShiftState(ALPHABET_AUTOMATIC_SHIFTED); + + // Press and slide from "123?" key. + pressAndSlideFromKey(CODE_SYMBOL, SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + + // Enter and release symbol letter keys, back to alphabet. + pressAndReleaseKey('1', SYMBOLS_UNSHIFTED, ALPHABET_UNSHIFTED); + } + + // Long press shift key. + // TODO: Move long press recognizing timer/logic into KeyboardState. + public void testLongPressShift() { + // Long press shift key, enter alphabet shift locked. + longPressShiftKey(ALPHABET_MANUAL_SHIFTED, ALPHABET_SHIFT_LOCKED); + + // Press/release letter key, remain in shift locked. + pressAndReleaseKey('A', ALPHABET_SHIFT_LOCKED, ALPHABET_SHIFT_LOCKED); + + // Press/release letter key, remain in shift locked. + pressAndReleaseKey('B', ALPHABET_SHIFT_LOCKED, ALPHABET_SHIFT_LOCKED); + + // Press/release word separator, remain in shift locked. + pressAndReleaseKey(CODE_SPACE, ALPHABET_SHIFT_LOCKED, ALPHABET_SHIFT_LOCKED); + + // Long press shift key, back to alphabet. + longPressShiftKey(ALPHABET_MANUAL_SHIFTED, ALPHABET_UNSHIFTED); + } + + // Leave shift lock with single tap shift key. + public void testShiftInShiftLock() { + // Long press shift key, enter alphabet shift locked. + longPressShiftKey(ALPHABET_MANUAL_SHIFTED, ALPHABET_SHIFT_LOCKED); + + // Press/release shift key, back to alphabet. + pressAndReleaseKey(CODE_SHIFT, ALPHABET_MANUAL_SHIFTED, ALPHABET_UNSHIFTED); + } + + // Double tap shift key. + // TODO: Move double tap recognizing timer/logic into KeyboardState. + public void testDoubleTapShift() { + // First shift key tap. + pressAndReleaseKey(CODE_SHIFT, ALPHABET_MANUAL_SHIFTED, ALPHABET_MANUAL_SHIFTED); + + // Second shift key tap. + // Double tap recognized in LatinKeyboardView.KeyTimerHandler. + secondTapShiftKey(ALPHABET_SHIFT_LOCKED); + + // First shift key tap. + pressAndReleaseKey(CODE_SHIFT, ALPHABET_MANUAL_SHIFTED, ALPHABET_UNSHIFTED); + + // Second shift key tap. + // Second tap is ignored in LatinKeyboardView.KeyTimerHandler. + } + + // Update shift state. + public void testUpdateShiftState() { + // Set auto caps mode on. + setAutoCapsMode(AUTO_CAPS); + + // Update shift state. + updateShiftState(ALPHABET_AUTOMATIC_SHIFTED); + + // Press/release letter key, back to alphabet. + pressAndReleaseKey('A', ALPHABET_AUTOMATIC_SHIFTED, ALPHABET_UNSHIFTED); + + // Press/release letter key + pressAndReleaseKey('b', ALPHABET_UNSHIFTED, ALPHABET_UNSHIFTED); + + // Press/release auto caps trigger letter, back to automatic shifted. + pressAndReleaseKey(CODE_AUTO_CAPS_TRIGGER, ALPHABET_UNSHIFTED, ALPHABET_AUTOMATIC_SHIFTED); + } + + // Update shift state when shift locked. + public void testUpdateShiftStateInShiftLocked() { + // Set auto caps mode on. + setAutoCapsMode(AUTO_CAPS); + + // Long press shift key, enter alphabet shift locked. + longPressShiftKey(ALPHABET_MANUAL_SHIFTED, ALPHABET_SHIFT_LOCKED); + + // Update shift state when shift locked + updateShiftState(ALPHABET_SHIFT_LOCKED); + } + + // Change focus to new text field. + public void testChangeFocus() { + // Press/release shift key. + pressAndReleaseKey(CODE_SHIFT, ALPHABET_MANUAL_SHIFTED, ALPHABET_MANUAL_SHIFTED); + // Change focus to new text field. + loadKeyboard(ALPHABET_UNSHIFTED); + + // Long press shift key, enter alphabet shift locked. + longPressShiftKey(ALPHABET_MANUAL_SHIFTED, ALPHABET_SHIFT_LOCKED); + // Change focus to new text field. + loadKeyboard(ALPHABET_UNSHIFTED); + + // Press/release symbol key. + pressAndReleaseKey(CODE_SYMBOL, SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + // Change focus to new text field. + loadKeyboard(ALPHABET_UNSHIFTED); + + // Press/release symbol key. + pressAndReleaseKey(CODE_SYMBOL, SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + // Press/release shift key. + pressAndReleaseKey(CODE_SHIFT, SYMBOLS_SHIFTED, SYMBOLS_SHIFTED); + // Change focus to new text field. + loadKeyboard(ALPHABET_UNSHIFTED); + } + + // Change focus to auto caps text field. + public void testChangeFocusAutoCaps() { + // Set auto caps mode on. + setAutoCapsMode(AUTO_CAPS); + + // Update shift state. + updateShiftState(ALPHABET_AUTOMATIC_SHIFTED); + // Change focus to new text field. + loadKeyboard(ALPHABET_AUTOMATIC_SHIFTED); + + // Press/release shift key, enter alphabet. + pressAndReleaseKey(CODE_SHIFT, ALPHABET_MANUAL_SHIFTED, ALPHABET_UNSHIFTED); + // Change focus to new text field. + loadKeyboard(ALPHABET_AUTOMATIC_SHIFTED); + + // Long press shift key, enter alphabet shift locked. + longPressShiftKey(ALPHABET_MANUAL_SHIFTED, ALPHABET_SHIFT_LOCKED); + // Change focus to new text field. + loadKeyboard(ALPHABET_AUTOMATIC_SHIFTED); + + // Press/release symbol key. + pressAndReleaseKey(CODE_SYMBOL, SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + // Change focus to new text field. + loadKeyboard(ALPHABET_AUTOMATIC_SHIFTED); + + // Press/release symbol key. + pressAndReleaseKey(CODE_SYMBOL, SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + // Press/release shift key. + pressAndReleaseKey(CODE_SHIFT, SYMBOLS_SHIFTED, SYMBOLS_SHIFTED); + // Change focus to new text field. + loadKeyboard(ALPHABET_AUTOMATIC_SHIFTED); + } + + // Change orientation. + public void testChangeOrientation() { + // Press/release shift key. + pressAndReleaseKey(CODE_SHIFT, ALPHABET_MANUAL_SHIFTED, ALPHABET_MANUAL_SHIFTED); + // Rotate device. + rotateDevice(ALPHABET_MANUAL_SHIFTED); + + // Long press shift key, enter alphabet shift locked. + longPressShiftKey(ALPHABET_MANUAL_SHIFTED, ALPHABET_SHIFT_LOCKED); + // Rotate device. + rotateDevice(ALPHABET_SHIFT_LOCKED); + + // Press/release symbol key. + pressAndReleaseKey(CODE_SYMBOL, SYMBOLS_UNSHIFTED, SYMBOLS_UNSHIFTED); + // Rotate device. + rotateDevice(SYMBOLS_UNSHIFTED); + + // Press/release shift key. + pressAndReleaseKey(CODE_SHIFT, SYMBOLS_SHIFTED, SYMBOLS_SHIFTED); + // Rotate device. + rotateDevice(SYMBOLS_SHIFTED); + } +} diff --git a/tests/src/com/android/inputmethod/keyboard/internal/KeyboardStateTests.java b/tests/src/com/android/inputmethod/keyboard/internal/KeyboardStateTests.java deleted file mode 100644 index 19339f72e..000000000 --- a/tests/src/com/android/inputmethod/keyboard/internal/KeyboardStateTests.java +++ /dev/null @@ -1,117 +0,0 @@ -/* - * 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.keyboard.internal; - -public class KeyboardStateTests extends KeyboardStateNonDistinctTests { - @Override - public boolean hasDistinctMultitouch() { - return true; - } - - // Shift key chording input. - public void testShiftChording() { - // Press shift key and hold, enter into choring shift state. - mSwitcher.onPressKey(CODE_SHIFT); - assertAlphabetManualShifted(); - - // Press/release letter keys. - mSwitcher.onPressKey('Z'); - mSwitcher.onCodeInput('Z', MULTI); - mSwitcher.onReleaseKey('Z'); - assertAlphabetManualShifted(); - mSwitcher.onPressKey('X'); - mSwitcher.onCodeInput('X', MULTI); - mSwitcher.onReleaseKey('X'); - assertAlphabetManualShifted(); - - // Release shift key, snap back to normal state. - mSwitcher.onCodeInput(CODE_SHIFT); - mSwitcher.onReleaseKey(CODE_SHIFT); - mSwitcher.updateShiftState(); - assertAlphabetNormal(); - } - - // Symbols key chording input. - public void testSymbolsChording() { - // Press symbols key and hold, enter into choring shift state. - mSwitcher.onPressKey(CODE_SYMBOL); - assertSymbolsNormal(); - - // Press/release symbol letter keys. - mSwitcher.onPressKey('1'); - mSwitcher.onCodeInput('1', MULTI); - mSwitcher.onReleaseKey('1'); - assertSymbolsNormal(); - mSwitcher.onPressKey('2'); - mSwitcher.onCodeInput('2', MULTI); - mSwitcher.onReleaseKey('2'); - assertSymbolsNormal(); - - // Release shift key, snap back to normal state. - mSwitcher.onCodeInput(CODE_SYMBOL); - mSwitcher.onReleaseKey(CODE_SYMBOL); - mSwitcher.updateShiftState(); - assertAlphabetNormal(); - } - - // Chording shift key in automatic upper case. - public void testAutomaticUpperCaseChording() { - mSwitcher.setAutoCapsMode(AUTO_CAPS); - // Update shift state with auto caps enabled. - mSwitcher.updateShiftState(); - assertAlphabetAutomaticShifted(); - - // Press shift key. - mSwitcher.onPressKey(CODE_SHIFT); - assertAlphabetManualShifted(); - // Press/release letter keys. - mSwitcher.onPressKey('Z'); - mSwitcher.onCodeInput('Z', MULTI); - mSwitcher.onReleaseKey('Z'); - assertAlphabetManualShifted(); - // Release shift key, snap back to alphabet. - mSwitcher.onCodeInput(CODE_SHIFT); - mSwitcher.onReleaseKey(CODE_SHIFT); - assertAlphabetNormal(); - } - - // Chording symbol key in automatic upper case. - public void testAutomaticUpperCaseChrding2() { - mSwitcher.setAutoCapsMode(AUTO_CAPS); - // Update shift state with auto caps enabled. - mSwitcher.updateShiftState(); - assertAlphabetAutomaticShifted(); - - // Press "123?" key. - mSwitcher.onPressKey(CODE_SYMBOL); - assertSymbolsNormal(); - // Press/release symbol letter keys. - mSwitcher.onPressKey('1'); - assertSymbolsNormal(); - mSwitcher.onCodeInput('1', MULTI); - mSwitcher.onReleaseKey('1'); - assertSymbolsNormal(); - // Release "123?" key, snap back to alphabet. - mSwitcher.onCodeInput(CODE_SYMBOL); - mSwitcher.onReleaseKey(CODE_SYMBOL); - assertAlphabetNormal(); - } - - // TODO: Multitouch test - - // TODO: n-Keys roll over test -} diff --git a/tests/src/com/android/inputmethod/keyboard/internal/KeyboardStateTestsBase.java b/tests/src/com/android/inputmethod/keyboard/internal/KeyboardStateTestsBase.java new file mode 100644 index 000000000..62df2cfe2 --- /dev/null +++ b/tests/src/com/android/inputmethod/keyboard/internal/KeyboardStateTestsBase.java @@ -0,0 +1,113 @@ +/* + * Copyright (C) 2012 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.keyboard.internal; + +import android.test.AndroidTestCase; + +public class KeyboardStateTestsBase extends AndroidTestCase + implements MockKeyboardSwitcher.Constants { + protected MockKeyboardSwitcher mSwitcher; + + private String mLayoutSwitchBackSymbols = ""; + + @Override + protected void setUp() throws Exception { + super.setUp(); + + mSwitcher = new MockKeyboardSwitcher(); + mSwitcher.setAutoCapsMode(NO_AUTO_CAPS); + + loadKeyboard(ALPHABET_UNSHIFTED); + } + + public void setAutoCapsMode(boolean autoCaps) { + mSwitcher.setAutoCapsMode(autoCaps); + } + + public void setLayoutSwitchBackSymbols(String switchBackSymbols) { + mLayoutSwitchBackSymbols = switchBackSymbols; + } + + public void updateShiftState(int afterUpdate) { + mSwitcher.updateShiftState(); + assertEquals(afterUpdate, mSwitcher.getLayoutId()); + } + + public void loadKeyboard(int afterLoad) { + mSwitcher.loadKeyboard(mLayoutSwitchBackSymbols); + updateShiftState(afterLoad); + } + + public void rotateDevice(int afterRotate) { + mSwitcher.saveKeyboardState(); + mSwitcher.loadKeyboard(mLayoutSwitchBackSymbols); + assertEquals(afterRotate, mSwitcher.getLayoutId()); + } + + public void pressKey(int code, int afterPress) { + mSwitcher.onPressKey(code); + assertEquals(afterPress, mSwitcher.getLayoutId()); + } + + public void releaseKey(int code, int afterRelease) { + mSwitcher.onCodeInput(code, SINGLE); + mSwitcher.onReleaseKey(code, NOT_SLIDING); + assertEquals(afterRelease, mSwitcher.getLayoutId()); + } + + public void pressAndReleaseKey(int code, int afterPress, int afterRelease) { + pressKey(code, afterPress); + releaseKey(code, afterRelease); + } + + public void chordingPressKey(int code, int afterPress) { + pressKey(code, afterPress); + } + + public void chordingReleaseKey(int code, int afterRelease) { + mSwitcher.onCodeInput(code, MULTI); + mSwitcher.onReleaseKey(code, NOT_SLIDING); + assertEquals(afterRelease, mSwitcher.getLayoutId()); + } + + public void chordingPressAndReleaseKey(int code, int afterPress, int afterRelease) { + chordingPressKey(code, afterPress); + chordingReleaseKey(code, afterRelease); + } + + public void pressAndSlideFromKey(int code, int afterPress, int afterSlide) { + pressKey(code, afterPress); + mSwitcher.onReleaseKey(code, SLIDING); + assertEquals(afterSlide, mSwitcher.getLayoutId()); + } + + public void longPressShiftKey(int afterPress, int afterLongPress) { + // Long press shift key + mSwitcher.onPressKey(CODE_SHIFT); + assertEquals(afterPress, mSwitcher.getLayoutId()); + // Long press recognized in LatinKeyboardView.KeyTimerHandler. + mSwitcher.onCodeInput(CODE_CAPSLOCK, SINGLE); + assertEquals(afterLongPress, mSwitcher.getLayoutId()); + mSwitcher.onReleaseKey(CODE_SHIFT, NOT_SLIDING); + assertEquals(afterLongPress, mSwitcher.getLayoutId()); + } + + public void secondTapShiftKey(int afterTap) { + mSwitcher.onCodeInput(CODE_CAPSLOCK, SINGLE); + assertEquals(afterTap, mSwitcher.getLayoutId()); + } +} diff --git a/tests/src/com/android/inputmethod/keyboard/internal/MockKeyboardSwitcher.java b/tests/src/com/android/inputmethod/keyboard/internal/MockKeyboardSwitcher.java index 1e294d179..87b463609 100644 --- a/tests/src/com/android/inputmethod/keyboard/internal/MockKeyboardSwitcher.java +++ b/tests/src/com/android/inputmethod/keyboard/internal/MockKeyboardSwitcher.java @@ -21,10 +21,10 @@ import com.android.inputmethod.keyboard.internal.KeyboardState.SwitchActions; public class MockKeyboardSwitcher implements KeyboardState.SwitchActions { public interface Constants { - // Argument for KeyboardState.onPressKey and onReleaseKey. + // Argument for {@link KeyboardState#onPressKey} and {@link KeyboardState#onReleaseKey}. public static final boolean NOT_SLIDING = false; public static final boolean SLIDING = true; - // Argument for KeyboardState.onCodeInput. + // Argument for {@link KeyboardState#onCodeInput}. public static final boolean SINGLE = true; public static final boolean MULTI = false; public static final boolean NO_AUTO_CAPS = false; @@ -34,18 +34,17 @@ public class MockKeyboardSwitcher implements KeyboardState.SwitchActions { public static final int CODE_SYMBOL = Keyboard.CODE_SWITCH_ALPHA_SYMBOL; public static final int CODE_CAPSLOCK = Keyboard.CODE_CAPSLOCK; public static final int CODE_SPACE = Keyboard.CODE_SPACE; - } - - public static final String WORD_SEPARATORS = " ,."; + public static final int CODE_AUTO_CAPS_TRIGGER = Keyboard.CODE_SPACE; - private static final int ALPHABET_UNSHIFTED = 0; - private static final int ALPHABET_MANUAL_SHIFTED = 1; - private static final int ALPHABET_AUTOMATIC_SHIFTED = 2; - private static final int ALPHABET_SHIFT_LOCKED = 3; - private static final int SYMBOLS_UNSHIFTED = 4; - private static final int SYMBOLS_SHIFTED = 5; + public static final int ALPHABET_UNSHIFTED = 0; + public static final int ALPHABET_MANUAL_SHIFTED = 1; + public static final int ALPHABET_AUTOMATIC_SHIFTED = 2; + public static final int ALPHABET_SHIFT_LOCKED = 3; + public static final int SYMBOLS_UNSHIFTED = 4; + public static final int SYMBOLS_SHIFTED = 5; + } - private int mLayout = ALPHABET_UNSHIFTED; + private int mLayout = Constants.ALPHABET_UNSHIFTED; private boolean mAutoCapsMode = Constants.NO_AUTO_CAPS; // Following InputConnection's behavior. Simulating InputType.TYPE_TEXT_FLAG_CAP_WORDS. @@ -53,28 +52,8 @@ public class MockKeyboardSwitcher implements KeyboardState.SwitchActions { private final KeyboardState mState = new KeyboardState(this); - public boolean assertAlphabetNormal() { - return mLayout == ALPHABET_UNSHIFTED; - } - - public boolean assertAlphabetManualShifted() { - return mLayout == ALPHABET_MANUAL_SHIFTED; - } - - public boolean assertAlphabetAutomaticShifted() { - return mLayout == ALPHABET_AUTOMATIC_SHIFTED; - } - - public boolean assertAlphabetShiftLocked() { - return mLayout == ALPHABET_SHIFT_LOCKED; - } - - public boolean assertSymbolsNormal() { - return mLayout == SYMBOLS_UNSHIFTED; - } - - public boolean assertSymbolsShifted() { - return mLayout == SYMBOLS_SHIFTED; + public int getLayoutId() { + return mLayout; } public void setAutoCapsMode(boolean autoCaps) { @@ -83,37 +62,37 @@ public class MockKeyboardSwitcher implements KeyboardState.SwitchActions { @Override public void setAlphabetKeyboard() { - mLayout = ALPHABET_UNSHIFTED; + mLayout = Constants.ALPHABET_UNSHIFTED; } @Override public void setShifted(int shiftMode) { if (shiftMode == SwitchActions.UNSHIFT) { - mLayout = ALPHABET_UNSHIFTED; + mLayout = Constants.ALPHABET_UNSHIFTED; } else if (shiftMode == SwitchActions.MANUAL_SHIFT) { - mLayout = ALPHABET_MANUAL_SHIFTED; + mLayout = Constants.ALPHABET_MANUAL_SHIFTED; } else if (shiftMode == SwitchActions.AUTOMATIC_SHIFT) { - mLayout = ALPHABET_AUTOMATIC_SHIFTED; + mLayout = Constants.ALPHABET_AUTOMATIC_SHIFTED; } } @Override public void setShiftLocked(boolean shiftLocked) { if (shiftLocked) { - mLayout = ALPHABET_SHIFT_LOCKED; + mLayout = Constants.ALPHABET_SHIFT_LOCKED; } else { - mLayout = ALPHABET_UNSHIFTED; + mLayout = Constants.ALPHABET_UNSHIFTED; } } @Override public void setSymbolsKeyboard() { - mLayout = SYMBOLS_UNSHIFTED; + mLayout = Constants.SYMBOLS_UNSHIFTED; } @Override public void setSymbolsShiftedKeyboard() { - mLayout = SYMBOLS_SHIFTED; + mLayout = Constants.SYMBOLS_SHIFTED; } @Override @@ -125,29 +104,26 @@ public class MockKeyboardSwitcher implements KeyboardState.SwitchActions { mState.onUpdateShiftState(mAutoCapsMode && mAutoCapsState); } - public void loadKeyboard(String layoutSwitchBackSymbols, - boolean hasDistinctMultitouch) { - mState.onLoadKeyboard(layoutSwitchBackSymbols, hasDistinctMultitouch); + public void loadKeyboard(String layoutSwitchBackSymbols) { + mState.onLoadKeyboard(layoutSwitchBackSymbols); } - public void onPressKey(int code) { - mState.onPressKey(code); + public void saveKeyboardState() { + mState.onSaveKeyboardState(); } - public void onReleaseKey(int code) { - onReleaseKey(code, Constants.NOT_SLIDING); + public void onPressKey(int code) { + mState.onPressKey(code); } public void onReleaseKey(int code, boolean withSliding) { mState.onReleaseKey(code, withSliding); } - public void onCodeInput(int code) { - onCodeInput(code, Constants.SINGLE); - } - public void onCodeInput(int code, boolean isSinglePointer) { - mAutoCapsState = (WORD_SEPARATORS.indexOf(code) >= 0); + if (Keyboard.isLetterCode(code)) { + mAutoCapsState = (code == Constants.CODE_AUTO_CAPS_TRIGGER); + } mState.onCodeInput(code, isSinglePointer, mAutoCapsMode && mAutoCapsState); } diff --git a/tests/src/com/android/inputmethod/keyboard/internal/MoreKeySpecParserTests.java b/tests/src/com/android/inputmethod/keyboard/internal/MoreKeySpecParserTests.java index 0eb324234..74aaf9af8 100644 --- a/tests/src/com/android/inputmethod/keyboard/internal/MoreKeySpecParserTests.java +++ b/tests/src/com/android/inputmethod/keyboard/internal/MoreKeySpecParserTests.java @@ -25,11 +25,11 @@ import com.android.inputmethod.latin.R; public class MoreKeySpecParserTests extends AndroidTestCase { private Resources mRes; - private static final int ICON_SETTINGS_KEY = 5; + private static final int ICON_SETTINGS_KEY = R.styleable.Keyboard_iconSettingsKey; private static final int ICON_UNDEFINED = KeyboardIconsSet.ICON_UNDEFINED; private static final String CODE_SETTINGS = "@integer/key_settings"; - private static final String ICON_SETTINGS = "@icon/" + ICON_SETTINGS_KEY; + private static final String ICON_SETTINGS = "@icon/settingsKey"; private static final String CODE_NON_EXISTING = "@integer/non_existing"; private static final String ICON_NON_EXISTING = "@icon/non_existing"; @@ -53,7 +53,7 @@ public class MoreKeySpecParserTests extends AndroidTestCase { String actualOutputText = MoreKeySpecParser.getOutputText(moreKeySpec); assertEquals(message + ": ouptputText:", expectedOutputText, actualOutputText); - int actualIcon = MoreKeySpecParser.getIconId(moreKeySpec); + int actualIcon = MoreKeySpecParser.getIconAttrId(moreKeySpec); assertEquals(message + ": icon:", expectedIcon, actualIcon); int actualCode = MoreKeySpecParser.getCode(mRes, moreKeySpec); @@ -66,7 +66,7 @@ public class MoreKeySpecParserTests extends AndroidTestCase { assertParser(message, moreKeySpec, expectedLabel, expectedOutputText, expectedIcon, expectedCode); fail(message); - } catch (MoreKeySpecParser.MoreKeySpecParserError pcpe) { + } catch (Exception pcpe) { // success. } } @@ -89,78 +89,78 @@ public class MoreKeySpecParserTests extends AndroidTestCase { assertParser("Single escaped at", "\\@", "@", null, ICON_UNDEFINED, '@'); assertParser("Single letter with outputText", "a|abc", - "a", "abc", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "a", "abc", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Single letter with escaped outputText", "a|a\\|c", - "a", "a|c", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "a", "a|c", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Single letter with comma outputText", "a|a,b", - "a", "a,b", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "a", "a,b", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Single letter with escaped comma outputText", "a|a\\,b", - "a", "a,b", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "a", "a,b", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Single letter with outputText starts with at", "a|@bc", - "a", "@bc", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "a", "@bc", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Single letter with outputText contains at", "a|a@c", - "a", "a@c", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "a", "a@c", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Single letter with escaped at outputText", "a|\\@bc", - "a", "@bc", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "a", "@bc", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Single escaped escape with outputText", "\\\\|\\\\", - "\\", "\\", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "\\", "\\", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Single escaped bar with outputText", "\\||\\|", - "|", "|", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "|", "|", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Single letter with code", "a|" + CODE_SETTINGS, "a", null, ICON_UNDEFINED, mCodeSettings); } public void testLabel() { assertParser("Simple label", "abc", - "abc", "abc", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "abc", "abc", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Label with escaped bar", "a\\|c", - "a|c", "a|c", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "a|c", "a|c", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Label with escaped escape", "a\\\\c", - "a\\c", "a\\c", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "a\\c", "a\\c", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Label with comma", "a,c", - "a,c", "a,c", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "a,c", "a,c", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Label with escaped comma", "a\\,c", - "a,c", "a,c", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "a,c", "a,c", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Label starts with at", "@bc", - "@bc", "@bc", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "@bc", "@bc", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Label contains at", "a@c", - "a@c", "a@c", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "a@c", "a@c", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Label with escaped at", "\\@bc", - "@bc", "@bc", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "@bc", "@bc", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Label with escaped letter", "\\abc", - "abc", "abc", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "abc", "abc", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Label with outputText", "abc|def", - "abc", "def", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "abc", "def", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Label with comma and outputText", "a,c|def", - "a,c", "def", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "a,c", "def", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Escaped comma label with outputText", "a\\,c|def", - "a,c", "def", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "a,c", "def", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Escaped label with outputText", "a\\|c|def", - "a|c", "def", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "a|c", "def", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Label with escaped bar outputText", "abc|d\\|f", - "abc", "d|f", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "abc", "d|f", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Escaped escape label with outputText", "a\\\\|def", - "a\\", "def", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "a\\", "def", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Label starts with at and outputText", "@bc|def", - "@bc", "def", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "@bc", "def", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Label contains at label and outputText", "a@c|def", - "a@c", "def", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "a@c", "def", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Escaped at label with outputText", "\\@bc|def", - "@bc", "def", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "@bc", "def", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Label with comma outputText", "abc|a,b", - "abc", "a,b", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "abc", "a,b", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Label with escaped comma outputText", "abc|a\\,b", - "abc", "a,b", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "abc", "a,b", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Label with outputText starts with at", "abc|@bc", - "abc", "@bc", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "abc", "@bc", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Label with outputText contains at", "abc|a@c", - "abc", "a@c", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "abc", "a@c", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Label with escaped at outputText", "abc|\\@bc", - "abc", "@bc", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "abc", "@bc", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Label with escaped bar outputText", "abc|d\\|f", - "abc", "d|f", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "abc", "d|f", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Escaped bar label with escaped bar outputText", "a\\|c|d\\|f", - "a|c", "d|f", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + "a|c", "d|f", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParser("Label with code", "abc|" + CODE_SETTINGS, "abc", null, ICON_UNDEFINED, mCodeSettings); assertParser("Escaped label with code", "a\\|c|" + CODE_SETTINGS, @@ -169,13 +169,13 @@ public class MoreKeySpecParserTests extends AndroidTestCase { public void testIconAndCode() { assertParser("Icon with outputText", ICON_SETTINGS + "|abc", - null, "abc", ICON_SETTINGS_KEY, Keyboard.CODE_UNSPECIFIED); + null, "abc", ICON_SETTINGS_KEY, Keyboard.CODE_OUTPUT_TEXT); assertParser("Icon with outputText starts with at", ICON_SETTINGS + "|@bc", - null, "@bc", ICON_SETTINGS_KEY, Keyboard.CODE_UNSPECIFIED); + null, "@bc", ICON_SETTINGS_KEY, Keyboard.CODE_OUTPUT_TEXT); assertParser("Icon with outputText contains at", ICON_SETTINGS + "|a@c", - null, "a@c", ICON_SETTINGS_KEY, Keyboard.CODE_UNSPECIFIED); + null, "a@c", ICON_SETTINGS_KEY, Keyboard.CODE_OUTPUT_TEXT); assertParser("Icon with escaped at outputText", ICON_SETTINGS + "|\\@bc", - null, "@bc", ICON_SETTINGS_KEY, Keyboard.CODE_UNSPECIFIED); + null, "@bc", ICON_SETTINGS_KEY, Keyboard.CODE_OUTPUT_TEXT); assertParser("Label starts with at and code", "@bc|" + CODE_SETTINGS, "@bc", null, ICON_UNDEFINED, mCodeSettings); assertParser("Label contains at and code", "a@c|" + CODE_SETTINGS, @@ -201,8 +201,8 @@ public class MoreKeySpecParserTests extends AndroidTestCase { null, null, ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); assertParserError("Icon without code", ICON_SETTINGS, null, null, ICON_SETTINGS_KEY, Keyboard.CODE_UNSPECIFIED); - assertParser("Non existing icon", ICON_NON_EXISTING + "|abc", - null, "abc", ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + assertParserError("Non existing icon", ICON_NON_EXISTING + "|abc", + null, "abc", ICON_UNDEFINED, Keyboard.CODE_OUTPUT_TEXT); assertParserError("Non existing code", "abc|" + CODE_NON_EXISTING, "abc", null, ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); assertParserError("Third bar at end", "a|b|", diff --git a/tests/src/com/android/inputmethod/latin/InputLogicTests.java b/tests/src/com/android/inputmethod/latin/InputLogicTests.java new file mode 100644 index 000000000..06ee5bffa --- /dev/null +++ b/tests/src/com/android/inputmethod/latin/InputLogicTests.java @@ -0,0 +1,122 @@ +/* + * Copyright (C) 2012 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; + +import android.content.Context; +import android.content.Intent; +import android.content.SharedPreferences; +import android.preference.PreferenceManager; +import android.test.ServiceTestCase; +import android.text.InputType; +import android.util.Log; +import android.view.LayoutInflater; +import android.view.ViewGroup; +import android.view.View; +import android.view.inputmethod.BaseInputConnection; +import android.view.inputmethod.EditorInfo; +import android.view.inputmethod.InputConnection; +import android.widget.FrameLayout; +import android.widget.TextView; + +import com.android.inputmethod.keyboard.Keyboard; +import com.android.inputmethod.keyboard.KeyboardActionListener; + +public class InputLogicTests extends ServiceTestCase<LatinIME> { + + private static final String PREF_DEBUG_MODE = "debug_mode"; + + private LatinIME mLatinIME; + private TextView mTextView; + + public InputLogicTests() { + super(LatinIME.class); + } + + // returns the previous setting value + private boolean setDebugMode(final boolean mode) { + final SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(mLatinIME); + final boolean previousDebugSetting = prefs.getBoolean(PREF_DEBUG_MODE, false); + final SharedPreferences.Editor editor = prefs.edit(); + editor.putBoolean(PREF_DEBUG_MODE, true); + editor.commit(); + return previousDebugSetting; + } + + @Override + protected void setUp() { + try { + super.setUp(); + } catch (Exception e) { + e.printStackTrace(); + } + mTextView = new TextView(getContext()); + mTextView.setInputType(InputType.TYPE_CLASS_TEXT); + mTextView.setEnabled(true); + setupService(); + mLatinIME = getService(); + final boolean previousDebugSetting = setDebugMode(true); + mLatinIME.onCreate(); + setDebugMode(previousDebugSetting); + final EditorInfo ei = new EditorInfo(); + final InputConnection ic = mTextView.onCreateInputConnection(ei); + final LayoutInflater inflater = + (LayoutInflater)getContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE); + final ViewGroup vg = new FrameLayout(getContext()); + final View inputView = inflater.inflate(R.layout.input_view, vg); + mLatinIME.setInputView(inputView); + mLatinIME.onBindInput(); + mLatinIME.onCreateInputView(); + mLatinIME.onStartInputView(ei, false); + mLatinIME.onCreateInputMethodInterface().startInput(ic, ei); + } + + // type(int) and type(String): helper methods to send a code point resp. a string to LatinIME. + private void type(final int codePoint) { + // onPressKey and onReleaseKey are explicitly deactivated here, but they do happen in the + // code (although multitouch/slide input and other factors make the sequencing complicated). + // They are supposed to be entirely deconnected from the input logic from LatinIME point of + // view and only delegates to the parts of the code that care. So we don't include them here + // to keep these tests as pinpoint as possible and avoid bringing it too many dependencies, + // but keep them in mind if something breaks. Commenting them out as is should work. + //mLatinIME.onPressKey(codePoint); + mLatinIME.onCodeInput(codePoint, new int[] { codePoint }, + KeyboardActionListener.NOT_A_TOUCH_COORDINATE, + KeyboardActionListener.NOT_A_TOUCH_COORDINATE); + //mLatinIME.onReleaseKey(codePoint, false); + } + + private void type(final String stringToType) { + for (int i = 0; i < stringToType.length(); ++i) { + type(stringToType.codePointAt(i)); + } + } + + public void testTypeWord() { + final String wordToType = "abcd"; + type(wordToType); + assertEquals("type word", wordToType, mTextView.getText().toString()); + } + + public void testPickSuggestionThenBackspace() { + final String wordToType = "tgis"; + type(wordToType); + mLatinIME.pickSuggestionManually(0, wordToType); + type(Keyboard.CODE_DELETE); + assertEquals("press suggestion then backspace", wordToType, mTextView.getText().toString()); + } + +} |