diff options
Diffstat (limited to 'tests')
16 files changed, 2614 insertions, 396 deletions
diff --git a/tests/Android.mk b/tests/Android.mk index fba7a8d74..658e8e294 100644 --- a/tests/Android.mk +++ b/tests/Android.mk @@ -7,6 +7,11 @@ LOCAL_CERTIFICATE := shared LOCAL_JAVA_LIBRARIES := android.test.runner +# Do not compress dictionary files to mmap dict data runtime +LOCAL_AAPT_FLAGS += -0 .dict +# Do not compress test data file +LOCAL_AAPT_FLAGS += -0 .txt + # Include all test java files. LOCAL_SRC_FILES := $(call all-java-files-under, src) diff --git a/tests/src/com/android/inputmethod/compat/ArraysCompatUtilsTests.java b/tests/src/com/android/inputmethod/compat/ArraysCompatUtilsTests.java new file mode 100644 index 000000000..93681b616 --- /dev/null +++ b/tests/src/com/android/inputmethod/compat/ArraysCompatUtilsTests.java @@ -0,0 +1,103 @@ +/* + * 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.compat; + +import android.test.AndroidTestCase; + +public class ArraysCompatUtilsTests extends AndroidTestCase { + // See {@link tests.api.java.util.ArraysTest}. + private static final int ARRAY_SIZE = 100; + private final int[] mIntArray = new int[ARRAY_SIZE]; + + @Override + protected void setUp() throws Exception { + super.setUp(); + for (int counter = 0; counter < ARRAY_SIZE; counter++) { + mIntArray[counter] = counter; + } + } + + public void testEmptyArray() { + final int index = ArraysCompatUtils.binarySearch(mIntArray, 0, 0, 0); + assertEquals("empty", ~0, index); + final int compat = ArraysCompatUtils.compatBinarySearch(mIntArray, 0, 0, 0); + assertEquals("empty compat", ~0, compat); + } + + public void testEmptyRangeArray() { + final int mid = ARRAY_SIZE / 3; + final int index = ArraysCompatUtils.binarySearch(mIntArray, mid, mid, 1); + assertEquals("empty", ~mid, index); + final int compat = ArraysCompatUtils.compatBinarySearch(mIntArray, mid, mid, 1); + assertEquals("empty compat", ~mid, compat); + } + + public void testFind() { + for (int counter = 0; counter < ARRAY_SIZE; counter++) { + final int index = ArraysCompatUtils.binarySearch(mIntArray, 0, ARRAY_SIZE, counter); + assertEquals("found", counter, index); + } + for (int counter = 0; counter < ARRAY_SIZE; counter++) { + final int compat = ArraysCompatUtils.compatBinarySearch( + mIntArray, 0, ARRAY_SIZE, counter); + assertEquals("found compat", counter, compat); + } + } + + public void testFindNegative() { + final int offset = ARRAY_SIZE / 2; + for (int counter = 0; counter < ARRAY_SIZE; counter++) { + mIntArray[counter] -= offset; + } + for (int counter = 0; counter < ARRAY_SIZE; counter++) { + final int index = ArraysCompatUtils.binarySearch( + mIntArray, 0, ARRAY_SIZE, counter - offset); + assertEquals("found", counter, index); + } + for (int counter = 0; counter < ARRAY_SIZE; counter++) { + final int compat = ArraysCompatUtils.compatBinarySearch( + mIntArray, 0, ARRAY_SIZE, counter - offset); + assertEquals("found compat", counter, compat); + } + } + + public void testNotFountAtTop() { + final int index = ArraysCompatUtils.binarySearch(mIntArray, 0, ARRAY_SIZE, -1); + assertEquals("not found top", ~0, index); + final int compat = ArraysCompatUtils.compatBinarySearch( + mIntArray, 0, ARRAY_SIZE, -1); + assertEquals("not found top compat", ~0, compat); + } + + public void testNotFountAtEnd() { + final int index = ArraysCompatUtils.binarySearch(mIntArray, 0, ARRAY_SIZE, ARRAY_SIZE); + assertEquals("not found end", ~ARRAY_SIZE, index); + final int compat = ArraysCompatUtils.compatBinarySearch( + mIntArray, 0, ARRAY_SIZE, ARRAY_SIZE); + assertEquals("not found end compat", ~ARRAY_SIZE, compat); + } + + public void testNotFountAtMid() { + final int mid = ARRAY_SIZE / 3; + mIntArray[mid] = mIntArray[mid + 1]; + final int index = ArraysCompatUtils.binarySearch(mIntArray, 0, ARRAY_SIZE, mid); + assertEquals("not found mid", ~mid, index); + final int compat = ArraysCompatUtils.compatBinarySearch( + mIntArray, 0, ARRAY_SIZE, mid); + assertEquals("not found mid compat", ~mid, compat); + } +} diff --git a/tests/src/com/android/inputmethod/keyboard/internal/KeyStylesTests.java b/tests/src/com/android/inputmethod/keyboard/internal/KeyStylesTests.java new file mode 100644 index 000000000..4050a7123 --- /dev/null +++ b/tests/src/com/android/inputmethod/keyboard/internal/KeyStylesTests.java @@ -0,0 +1,90 @@ +/* + * Copyright (C) 2010 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 com.android.inputmethod.keyboard.internal.KeyStyles.EmptyKeyStyle; + +import android.test.AndroidTestCase; +import android.text.TextUtils; + +public class KeyStylesTests extends AndroidTestCase { + 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); + if (expected.length == 0) { + assertNull(message, actual); + return; + } + assertSame(message + ": 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); + } + } + + public void testParseCsvTextZero() { + assertTextArray("Empty string", ""); + } + + public void testParseCsvTextSingle() { + assertTextArray("Single char", "a", "a"); + assertTextArray("Space", " ", " "); + assertTextArray("Single label", "abc", "abc"); + assertTextArray("Spaces", " ", " "); + 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 "); + } + + public void testParseCsvTextSingleEscaped() { + assertTextArray("Escaped char", "\\a", "a"); + assertTextArray("Escaped comma", "\\,", ","); + assertTextArray("Escaped escape", "\\\\", "\\"); + assertTextArray("Escaped label", "a\\bc", "abc"); + assertTextArray("Escaped label at begininng", "\\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"); + } + + public void testParseCsvTextMulti() { + assertTextArray("Multiple chars", "a,b,c", "a", "b", "c"); + assertTextArray("Multiple chars surrounded by spaces", " a , b , c ", " a ", " b ", " c "); + assertTextArray("Multiple labels", "abc,def,ghi", "abc", "def", "ghi"); + assertTextArray("Multiple labels surrounded by spaces", " abc , def , ghi ", + " abc ", " def ", " ghi "); + } + + public void testParseCsvTextMultiEscaped() { + assertTextArray("Multiple chars with comma", "a,\\,,c", "a", ",", "c"); + assertTextArray("Multiple chars with comma surrounded by spaces", " a , \\, , c ", + " a ", " , ", " c "); + assertTextArray("Multiple labels with escape", "\\abc,d\\ef,gh\\i", "abc", "def", "ghi"); + assertTextArray("Multiple labels with escape surrounded by spaces", + " \\abc , d\\ef , gh\\i ", " abc ", " def ", " ghi "); + assertTextArray("Multiple labels with comma and escape", + "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 "); + } +} diff --git a/tests/src/com/android/inputmethod/keyboard/internal/MiniKeyboardBuilderTests.java b/tests/src/com/android/inputmethod/keyboard/internal/MiniKeyboardBuilderTests.java new file mode 100644 index 000000000..0d2802d53 --- /dev/null +++ b/tests/src/com/android/inputmethod/keyboard/internal/MiniKeyboardBuilderTests.java @@ -0,0 +1,1416 @@ +/* + * 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; + +import com.android.inputmethod.keyboard.internal.MiniKeyboardBuilder.MiniKeyboardLayoutParams; + +import android.test.AndroidTestCase; + +public class MiniKeyboardBuilderTests extends AndroidTestCase { + private static final int MAX_COLUMNS = 5; + private static final int WIDTH = 10; + private static final int HEIGHT = 10; + + private static final int KEYBOARD_WIDTH = WIDTH * 10; + private static final int XPOS_L0 = WIDTH * 0; + private static final int XPOS_L1 = WIDTH * 1; + private static final int XPOS_L2 = WIDTH * 2; + private static final int XPOS_M0 = WIDTH * 5; + private static final int XPOS_R3 = WIDTH * 6; + private static final int XPOS_R2 = WIDTH * 7; + private static final int XPOS_R1 = WIDTH * 8; + private static final int XPOS_R0 = WIDTH * 9; + + @Override + protected void setUp() throws Exception { + super.setUp(); + } + + public void testLayoutError() { + MiniKeyboardLayoutParams params = null; + try { + params = new MiniKeyboardLayoutParams(10, MAX_COLUMNS + 1, WIDTH, HEIGHT, WIDTH * 2, + WIDTH * MAX_COLUMNS); + fail("Should throw IllegalArgumentException"); + } catch (IllegalArgumentException e) { + // Too small keyboard to hold mini keyboard. + } + assertNull("Too small keyboard to hold mini keyboard", params); + } + + // Mini keyboard layout test. + // "[n]" represents n-th key position in mini keyboard. + // "[1]" is the default key. + + // [1] + public void testLayout1KeyM0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(1, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_M0, KEYBOARD_WIDTH); + assertEquals("1 key M0 columns", 1, params.mNumColumns); + assertEquals("1 key M0 rows", 1, params.mNumRows); + assertEquals("1 key M0 left", 0, params.mLeftKeys); + assertEquals("1 key M0 right", 1, params.mRightKeys); + assertEquals("1 key M0 [1]", 0, params.getColumnPos(0)); + assertEquals("1 key M0 adjust", 0, params.mTopRowAdjustment); + assertEquals("1 key M0 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // |[1] + public void testLayout1KeyL0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(1, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L0, KEYBOARD_WIDTH); + assertEquals("1 key L0 columns", 1, params.mNumColumns); + assertEquals("1 key L0 rows", 1, params.mNumRows); + assertEquals("1 key L0 left", 0, params.mLeftKeys); + assertEquals("1 key L0 right", 1, params.mRightKeys); + assertEquals("1 key L0 [1]", 0, params.getColumnPos(0)); + assertEquals("1 key L0 adjust", 0, params.mTopRowAdjustment); + assertEquals("1 key L0 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // |___ [1] + public void testLayout1KeyL1() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(1, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L1, KEYBOARD_WIDTH); + assertEquals("1 key L1 columns", 1, params.mNumColumns); + assertEquals("1 key L1 rows", 1, params.mNumRows); + assertEquals("1 key L1 left", 0, params.mLeftKeys); + assertEquals("1 key L1 right", 1, params.mRightKeys); + assertEquals("1 key L1 [1]", 0, params.getColumnPos(0)); + assertEquals("1 key L1 adjust", 0, params.mTopRowAdjustment); + assertEquals("1 key L1 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // |___ ___ [1] + public void testLayout1KeyL2() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(1, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L2, KEYBOARD_WIDTH); + assertEquals("1 key L2 columns", 1, params.mNumColumns); + assertEquals("1 key L2 rows", 1, params.mNumRows); + assertEquals("1 key L2 left", 0, params.mLeftKeys); + assertEquals("1 key L2 right", 1, params.mRightKeys); + assertEquals("1 key L2 [1]", 0, params.getColumnPos(0)); + assertEquals("1 key L2 adjust", 0, params.mTopRowAdjustment); + assertEquals("1 key L2 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // [1]| + public void testLayout1KeyR0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(1, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R0, KEYBOARD_WIDTH); + assertEquals("1 key R0 columns", 1, params.mNumColumns); + assertEquals("1 key R0 rows", 1, params.mNumRows); + assertEquals("1 key R0 left", 0, params.mLeftKeys); + assertEquals("1 key R0 right", 1, params.mRightKeys); + assertEquals("1 key R0 [1]", 0, params.getColumnPos(0)); + assertEquals("1 key R0 adjust", 0, params.mTopRowAdjustment); + assertEquals("1 key R0 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // [1] ___| + public void testLayout1KeyR1() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(1, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R1, KEYBOARD_WIDTH); + assertEquals("1 key R1 columns", 1, params.mNumColumns); + assertEquals("1 key R1 rows", 1, params.mNumRows); + assertEquals("1 key R1 left", 0, params.mLeftKeys); + assertEquals("1 key R1 right", 1, params.mRightKeys); + assertEquals("1 key R1 [1]", 0, params.getColumnPos(0)); + assertEquals("1 key R1 adjust", 0, params.mTopRowAdjustment); + assertEquals("1 key R1 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // [1] ___ ___| + public void testLayout1KeyR2() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(1, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R2, KEYBOARD_WIDTH); + assertEquals("1 key R2 columns", 1, params.mNumColumns); + assertEquals("1 key R2 rows", 1, params.mNumRows); + assertEquals("1 key R2 left", 0, params.mLeftKeys); + assertEquals("1 key R2 right", 1, params.mRightKeys); + assertEquals("1 key R2 [1]", 0, params.getColumnPos(0)); + assertEquals("1 key R2 adjust", 0, params.mTopRowAdjustment); + assertEquals("1 key R2 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // [1] [2] + public void testLayout2KeyM0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(2, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_M0, KEYBOARD_WIDTH); + assertEquals("2 key M0 columns", 2, params.mNumColumns); + assertEquals("2 key M0 rows", 1, params.mNumRows); + assertEquals("2 key M0 left", 0, params.mLeftKeys); + assertEquals("2 key M0 right", 2, params.mRightKeys); + assertEquals("2 key M0 [1]", 0, params.getColumnPos(0)); + assertEquals("2 key M0 [2]", 1, params.getColumnPos(1)); + assertEquals("2 key M0 adjust", 0, params.mTopRowAdjustment); + assertEquals("2 key M0 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // |[1] [2] + public void testLayout2KeyL0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(2, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L0, KEYBOARD_WIDTH); + assertEquals("2 key L0 columns", 2, params.mNumColumns); + assertEquals("2 key L0 rows", 1, params.mNumRows); + assertEquals("2 key L0 left", 0, params.mLeftKeys); + assertEquals("2 key L0 right", 2, params.mRightKeys); + assertEquals("2 key L0 [1]", 0, params.getColumnPos(0)); + assertEquals("2 key L0 [2]", 1, params.getColumnPos(1)); + assertEquals("2 key L0 adjust", 0, params.mTopRowAdjustment); + assertEquals("2 key L0 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // |___ [1] [2] + public void testLayout2KeyL1() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(2, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L1, KEYBOARD_WIDTH); + assertEquals("2 key L1 columns", 2, params.mNumColumns); + assertEquals("2 key L1 rows", 1, params.mNumRows); + assertEquals("2 key L1 left", 0, params.mLeftKeys); + assertEquals("2 key L1 right", 2, params.mRightKeys); + assertEquals("2 key L1 [1]", 0, params.getColumnPos(0)); + assertEquals("2 key L1 [2]", 1, params.getColumnPos(1)); + assertEquals("2 key L1 adjust", 0, params.mTopRowAdjustment); + assertEquals("2 key L1 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // |___ ___ [1] [2] + public void testLayout2KeyL2() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(2, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L2, KEYBOARD_WIDTH); + assertEquals("2 key L2 columns", 2, params.mNumColumns); + assertEquals("2 key L2 rows", 1, params.mNumRows); + assertEquals("2 key L2 left", 0, params.mLeftKeys); + assertEquals("2 key L2 right", 2, params.mRightKeys); + assertEquals("2 key L2 [1]", 0, params.getColumnPos(0)); + assertEquals("2 key L2 [2]", 1, params.getColumnPos(1)); + assertEquals("2 key L2 adjust", 0, params.mTopRowAdjustment); + assertEquals("2 key L2 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // [2] [1]| + public void testLayout2KeyR0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(2, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R0, KEYBOARD_WIDTH); + assertEquals("2 key R0 columns", 2, params.mNumColumns); + assertEquals("2 key R0 rows", 1, params.mNumRows); + assertEquals("2 key R0 left", 1, params.mLeftKeys); + assertEquals("2 key R0 right", 1, params.mRightKeys); + assertEquals("2 key R0 [1]", 0, params.getColumnPos(0)); + assertEquals("2 key R0 [2]", -1, params.getColumnPos(1)); + assertEquals("2 key R0 adjust", 0, params.mTopRowAdjustment); + assertEquals("2 key R0 default", WIDTH * 1, params.getDefaultKeyCoordX()); + } + + // [2] [1] ___| + public void testLayout2KeyR1() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(2, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R1, KEYBOARD_WIDTH); + assertEquals("2 key R1 columns", 2, params.mNumColumns); + assertEquals("2 key R1 rows", 1, params.mNumRows); + assertEquals("2 key R1 left", 1, params.mLeftKeys); + assertEquals("2 key R1 right", 1, params.mRightKeys); + assertEquals("2 key R1 [1]", 0, params.getColumnPos(0)); + assertEquals("2 key R1 [2]", -1, params.getColumnPos(1)); + assertEquals("2 key R1 adjust", 0, params.mTopRowAdjustment); + assertEquals("2 key R1 default", WIDTH * 1, params.getDefaultKeyCoordX()); + } + + // [1] [2] ___ ___| + public void testLayout2KeyR2() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(2, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R2, KEYBOARD_WIDTH); + assertEquals("2 key R2 columns", 2, params.mNumColumns); + assertEquals("2 key R2 rows", 1, params.mNumRows); + assertEquals("2 key R2 left", 0, params.mLeftKeys); + assertEquals("2 key R2 right", 2, params.mRightKeys); + assertEquals("2 key R2 [1]", 0, params.getColumnPos(0)); + assertEquals("2 key R2 [2]", 1, params.getColumnPos(1)); + assertEquals("2 key R2 adjust", 0, params.mTopRowAdjustment); + assertEquals("2 key R2 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // [3] [1] [2] + public void testLayout3KeyM0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(3, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_M0, KEYBOARD_WIDTH); + assertEquals("3 key columns", 3, params.mNumColumns); + assertEquals("3 key rows", 1, params.mNumRows); + assertEquals("3 key left", 1, params.mLeftKeys); + assertEquals("3 key right", 2, params.mRightKeys); + assertEquals("3 key [1]", 0, params.getColumnPos(0)); + assertEquals("3 key [2]", 1, params.getColumnPos(1)); + assertEquals("3 key [3]", -1, params.getColumnPos(2)); + assertEquals("3 key adjust", 0, params.mTopRowAdjustment); + assertEquals("3 key default", WIDTH * 1, params.getDefaultKeyCoordX()); + } + + // |[1] [2] [3] + public void testLayout3KeyL0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(3, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L0, KEYBOARD_WIDTH); + assertEquals("3 key L0 columns", 3, params.mNumColumns); + assertEquals("3 key L0 rows", 1, params.mNumRows); + assertEquals("3 key L0 left", 0, params.mLeftKeys); + assertEquals("3 key L0 right", 3, params.mRightKeys); + assertEquals("3 key L0 [1]", 0, params.getColumnPos(0)); + assertEquals("3 key L0 [2]", 1, params.getColumnPos(1)); + assertEquals("3 key L0 [3]", 2, params.getColumnPos(2)); + assertEquals("3 key L0 adjust", 0, params.mTopRowAdjustment); + assertEquals("3 key L0 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // |___ [1] [2] [3] + public void testLayout3KeyL1() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(3, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L1, KEYBOARD_WIDTH); + assertEquals("3 key L1 columns", 3, params.mNumColumns); + assertEquals("3 key L1 rows", 1, params.mNumRows); + assertEquals("3 key L1 left", 0, params.mLeftKeys); + assertEquals("3 key L1 right", 3, params.mRightKeys); + assertEquals("3 key L1 [1]", 0, params.getColumnPos(0)); + assertEquals("3 key L1 [2]", 1, params.getColumnPos(1)); + assertEquals("3 key L1 [3]", 2, params.getColumnPos(2)); + assertEquals("3 key L1 adjust", 0, params.mTopRowAdjustment); + assertEquals("3 key L1 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // |___ ___ [3] [1] [2] + public void testLayout3KeyL2() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(3, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L2, KEYBOARD_WIDTH); + assertEquals("3 key L2 columns", 3, params.mNumColumns); + assertEquals("3 key L2 rows", 1, params.mNumRows); + assertEquals("3 key L2 left", 1, params.mLeftKeys); + assertEquals("3 key L2 right", 2, params.mRightKeys); + assertEquals("3 key L2 [1]", 0, params.getColumnPos(0)); + assertEquals("3 key L2 [2]", 1, params.getColumnPos(1)); + assertEquals("3 key L2 [3]", -1, params.getColumnPos(2)); + assertEquals("3 key L2 adjust", 0, params.mTopRowAdjustment); + assertEquals("3 key L2 default", WIDTH * 1, params.getDefaultKeyCoordX()); + } + + // [3] [2] [1]| + public void testLayout3KeyR0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(3, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R0, KEYBOARD_WIDTH); + assertEquals("3 key R0 columns", 3, params.mNumColumns); + assertEquals("3 key R0 rows", 1, params.mNumRows); + assertEquals("3 key R0 left", 2, params.mLeftKeys); + assertEquals("3 key R0 right", 1, params.mRightKeys); + assertEquals("3 key R0 [1]", 0, params.getColumnPos(0)); + assertEquals("3 key R0 [2]", -1, params.getColumnPos(1)); + assertEquals("3 key R0 [3]", -2, params.getColumnPos(2)); + assertEquals("3 key R0 adjust", 0, params.mTopRowAdjustment); + assertEquals("3 key R0 default", WIDTH * 2, params.getDefaultKeyCoordX()); + } + + // [3] [2] [1] ___| + public void testLayout3KeyR1() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(3, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R1, KEYBOARD_WIDTH); + assertEquals("3 key R1 columns", 3, params.mNumColumns); + assertEquals("3 key R1 rows", 1, params.mNumRows); + assertEquals("3 key R1 left", 2, params.mLeftKeys); + assertEquals("3 key R1 right", 1, params.mRightKeys); + assertEquals("3 key R1 [1]", 0, params.getColumnPos(0)); + assertEquals("3 key R1 [2]", -1, params.getColumnPos(1)); + assertEquals("3 key R1 [3]", -2, params.getColumnPos(2)); + assertEquals("3 key R1 adjust", 0, params.mTopRowAdjustment); + assertEquals("3 key R1 default", WIDTH * 2, params.getDefaultKeyCoordX()); + } + + // [3] [1] [2] ___ ___| + public void testLayout3KeyR2() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(3, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R2, KEYBOARD_WIDTH); + assertEquals("3 key R2 columns", 3, params.mNumColumns); + assertEquals("3 key R2 rows", 1, params.mNumRows); + assertEquals("3 key R2 left", 1, params.mLeftKeys); + assertEquals("3 key R2 right", 2, params.mRightKeys); + assertEquals("3 key R2 [1]", 0, params.getColumnPos(0)); + assertEquals("3 key R2 [2]", 1, params.getColumnPos(1)); + assertEquals("3 key R2 [3]", -1, params.getColumnPos(2)); + assertEquals("3 key R2 adjust", 0, params.mTopRowAdjustment); + assertEquals("3 key R2 default", WIDTH * 1, params.getDefaultKeyCoordX()); + } + + // [3] [1] [2] [4] + public void testLayout4KeyM0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(4, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_M0, KEYBOARD_WIDTH); + assertEquals("4 key columns", 4, params.mNumColumns); + assertEquals("4 key rows", 1, params.mNumRows); + assertEquals("4 key left", 1, params.mLeftKeys); + assertEquals("4 key right", 3, params.mRightKeys); + assertEquals("4 key [1]", 0, params.getColumnPos(0)); + assertEquals("4 key [2]", 1, params.getColumnPos(1)); + assertEquals("4 key [3]", -1, params.getColumnPos(2)); + assertEquals("4 key [4]", 2, params.getColumnPos(3)); + assertEquals("4 key adjust", 0, params.mTopRowAdjustment); + assertEquals("4 key default", WIDTH * 1, params.getDefaultKeyCoordX()); + } + + // |[1] [2] [3] [4] + public void testLayout4KeyL0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(4, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L0, KEYBOARD_WIDTH); + assertEquals("4 key L0 columns", 4, params.mNumColumns); + assertEquals("4 key L0 rows", 1, params.mNumRows); + assertEquals("4 key L0 left", 0, params.mLeftKeys); + assertEquals("4 key L0 right", 4, params.mRightKeys); + assertEquals("4 key L0 [1]", 0, params.getColumnPos(0)); + assertEquals("4 key L0 [2]", 1, params.getColumnPos(1)); + assertEquals("4 key L0 [3]", 2, params.getColumnPos(2)); + assertEquals("4 key L0 [4]", 3, params.getColumnPos(3)); + assertEquals("4 key L0 adjust", 0, params.mTopRowAdjustment); + assertEquals("4 key L0 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // |___ [1] [2] [3] [4] + public void testLayout4KeyL1() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(4, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L1, KEYBOARD_WIDTH); + assertEquals("4 key L1 columns", 4, params.mNumColumns); + assertEquals("4 key L1 rows", 1, params.mNumRows); + assertEquals("4 key L1 left", 0, params.mLeftKeys); + assertEquals("4 key L1 right", 4, params.mRightKeys); + assertEquals("4 key L1 [1]", 0, params.getColumnPos(0)); + assertEquals("4 key L1 [2]", 1, params.getColumnPos(1)); + assertEquals("4 key L1 [3]", 2, params.getColumnPos(2)); + assertEquals("4 key L1 [4]", 3, params.getColumnPos(3)); + assertEquals("4 key L1 adjust", 0, params.mTopRowAdjustment); + assertEquals("4 key L1 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // |___ ___ [3] [1] [2] [4] + public void testLayout4KeyL2() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(4, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L2, KEYBOARD_WIDTH); + assertEquals("4 key L2 columns", 4, params.mNumColumns); + assertEquals("4 key L2 rows", 1, params.mNumRows); + assertEquals("4 key L2 left", 1, params.mLeftKeys); + assertEquals("4 key L2 right", 3, params.mRightKeys); + assertEquals("4 key L2 [1]", 0, params.getColumnPos(0)); + assertEquals("4 key L2 [2]", 1, params.getColumnPos(1)); + assertEquals("4 key L2 [3]", -1, params.getColumnPos(2)); + assertEquals("4 key L2 [4]", 2, params.getColumnPos(3)); + assertEquals("4 key L2 adjust", 0, params.mTopRowAdjustment); + assertEquals("4 key L2 default", WIDTH * 1, params.getDefaultKeyCoordX()); + } + + // [4] [3] [2] [1]| + public void testLayout4KeyR0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(4, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R0, KEYBOARD_WIDTH); + assertEquals("4 key R0 columns", 4, params.mNumColumns); + assertEquals("4 key R0 rows", 1, params.mNumRows); + assertEquals("4 key R0 left", 3, params.mLeftKeys); + assertEquals("4 key R0 right", 1, params.mRightKeys); + assertEquals("4 key R0 [1]", 0, params.getColumnPos(0)); + assertEquals("4 key R0 [2]", -1, params.getColumnPos(1)); + assertEquals("4 key R0 [3]", -2, params.getColumnPos(2)); + assertEquals("4 key R0 [4]", -3, params.getColumnPos(3)); + assertEquals("4 key R0 adjust", 0, params.mTopRowAdjustment); + assertEquals("4 key R0 default", WIDTH * 3, params.getDefaultKeyCoordX()); + } + + // [4] [3] [2] [1] ___| + public void testLayout4KeyR1() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(4, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R1, KEYBOARD_WIDTH); + assertEquals("4 key R1 columns", 4, params.mNumColumns); + assertEquals("4 key R1 rows", 1, params.mNumRows); + assertEquals("4 key R1 left", 3, params.mLeftKeys); + assertEquals("4 key R1 right", 1, params.mRightKeys); + assertEquals("4 key R1 [1]", 0, params.getColumnPos(0)); + assertEquals("4 key R1 [2]", -1, params.getColumnPos(1)); + assertEquals("4 key R1 [3]", -2, params.getColumnPos(2)); + assertEquals("4 key R1 [4]", -3, params.getColumnPos(3)); + assertEquals("4 key R1 adjust", 0, params.mTopRowAdjustment); + assertEquals("4 key R1 default", WIDTH * 3, params.getDefaultKeyCoordX()); + } + + // [4] [3] [1] [2] ___ ___| + public void testLayout4KeyR2() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(4, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R2, KEYBOARD_WIDTH); + assertEquals("4 key R2 columns", 4, params.mNumColumns); + assertEquals("4 key R2 rows", 1, params.mNumRows); + assertEquals("4 key R2 left", 2, params.mLeftKeys); + assertEquals("4 key R2 right", 2, params.mRightKeys); + assertEquals("4 key R2 [1]", 0, params.getColumnPos(0)); + assertEquals("4 key R2 [2]", 1, params.getColumnPos(1)); + assertEquals("4 key R2 [3]", -1, params.getColumnPos(2)); + assertEquals("4 key R2 [4]", -2, params.getColumnPos(3)); + assertEquals("4 key R2 adjust", 0, params.mTopRowAdjustment); + assertEquals("4 key R2 default", WIDTH * 2, params.getDefaultKeyCoordX()); + } + + // [5] [3] [1] [2] [4] + public void testLayout5KeyM0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(5, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_M0, KEYBOARD_WIDTH); + assertEquals("5 key columns", 5, params.mNumColumns); + assertEquals("5 key rows", 1, params.mNumRows); + assertEquals("5 key left", 2, params.mLeftKeys); + assertEquals("5 key right", 3, params.mRightKeys); + assertEquals("5 key [1]", 0, params.getColumnPos(0)); + assertEquals("5 key [2]", 1, params.getColumnPos(1)); + assertEquals("5 key [3]", -1, params.getColumnPos(2)); + assertEquals("5 key [4]", 2, params.getColumnPos(3)); + assertEquals("5 key [5]", -2, params.getColumnPos(4)); + assertEquals("5 key adjust", 0, params.mTopRowAdjustment); + assertEquals("5 key default", WIDTH * 2, params.getDefaultKeyCoordX()); + } + + // |[1] [2] [3] [4] [5] + public void testLayout5KeyL0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(5, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L0, KEYBOARD_WIDTH); + assertEquals("5 key L0 columns", 5, params.mNumColumns); + assertEquals("5 key L0 rows", 1, params.mNumRows); + assertEquals("5 key L0 left", 0, params.mLeftKeys); + assertEquals("5 key L0 right", 5, params.mRightKeys); + assertEquals("5 key L0 [1]", 0, params.getColumnPos(0)); + assertEquals("5 key L0 [2]", 1, params.getColumnPos(1)); + assertEquals("5 key L0 [3]", 2, params.getColumnPos(2)); + assertEquals("5 key L0 [4]", 3, params.getColumnPos(3)); + assertEquals("5 key L0 [5]", 4, params.getColumnPos(4)); + assertEquals("5 key L0 adjust", 0, params.mTopRowAdjustment); + assertEquals("5 key L0 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // |___ [1] [2] [3] [4] [5] + public void testLayout5KeyL1() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(5, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L1, KEYBOARD_WIDTH); + assertEquals("5 key L1 columns", 5, params.mNumColumns); + assertEquals("5 key L1 rows", 1, params.mNumRows); + assertEquals("5 key L1 left", 0, params.mLeftKeys); + assertEquals("5 key L1 right", 5, params.mRightKeys); + assertEquals("5 key L1 [1]", 0, params.getColumnPos(0)); + assertEquals("5 key L1 [2]", 1, params.getColumnPos(1)); + assertEquals("5 key L1 [3]", 2, params.getColumnPos(2)); + assertEquals("5 key L1 [4]", 3, params.getColumnPos(3)); + assertEquals("5 key L1 [5]", 4, params.getColumnPos(4)); + assertEquals("5 key L1 adjust", 0, params.mTopRowAdjustment); + assertEquals("5 key L1 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // |___ ___ [3] [1] [2] [4] [5] + public void testLayout5KeyL2() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(5, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L2, KEYBOARD_WIDTH); + assertEquals("5 key L2 columns", 5, params.mNumColumns); + assertEquals("5 key L2 rows", 1, params.mNumRows); + assertEquals("5 key L2 left", 1, params.mLeftKeys); + assertEquals("5 key L2 right", 4, params.mRightKeys); + assertEquals("5 key L2 [1]", 0, params.getColumnPos(0)); + assertEquals("5 key L2 [2]", 1, params.getColumnPos(1)); + assertEquals("5 key L2 [3]", -1, params.getColumnPos(2)); + assertEquals("5 key L2 [4]", 2, params.getColumnPos(3)); + assertEquals("5 key L2 [5]", 3, params.getColumnPos(4)); + assertEquals("5 key L2 adjust", 0, params.mTopRowAdjustment); + assertEquals("5 key L2 default", WIDTH * 1, params.getDefaultKeyCoordX()); + } + + // [5] [4] [3] [2] [1]| + public void testLayout5KeyR0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(5, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R0, KEYBOARD_WIDTH); + assertEquals("5 key R0 columns", 5, params.mNumColumns); + assertEquals("5 key R0 rows", 1, params.mNumRows); + assertEquals("5 key R0 left", 4, params.mLeftKeys); + assertEquals("5 key R0 right", 1, params.mRightKeys); + assertEquals("5 key R0 [1]", 0, params.getColumnPos(0)); + assertEquals("5 key R0 [2]", -1, params.getColumnPos(1)); + assertEquals("5 key R0 [3]", -2, params.getColumnPos(2)); + assertEquals("5 key R0 [4]", -3, params.getColumnPos(3)); + assertEquals("5 key R0 [5]", -4, params.getColumnPos(4)); + assertEquals("5 key R0 adjust", 0, params.mTopRowAdjustment); + assertEquals("5 key R0 default", WIDTH * 4, params.getDefaultKeyCoordX()); + } + + // [5] [4] [3] [2] [1] ___| + public void testLayout5KeyR1() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(5, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R1, KEYBOARD_WIDTH); + assertEquals("5 key R1 columns", 5, params.mNumColumns); + assertEquals("5 key R1 rows", 1, params.mNumRows); + assertEquals("5 key R1 left", 4, params.mLeftKeys); + assertEquals("5 key R1 right", 1, params.mRightKeys); + assertEquals("5 key R1 [1]", 0, params.getColumnPos(0)); + assertEquals("5 key R1 [2]", -1, params.getColumnPos(1)); + assertEquals("5 key R1 [3]", -2, params.getColumnPos(2)); + assertEquals("5 key R1 [4]", -3, params.getColumnPos(3)); + assertEquals("5 key R1 [5]", -4, params.getColumnPos(4)); + assertEquals("5 key R1 adjust", 0, params.mTopRowAdjustment); + assertEquals("5 key R1 default", WIDTH * 4, params.getDefaultKeyCoordX()); + } + + // [5] [4] [3] [1] [2] ___ ___| + public void testLayout5KeyR2() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(5, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R2, KEYBOARD_WIDTH); + assertEquals("5 key R2 columns", 5, params.mNumColumns); + assertEquals("5 key R2 rows", 1, params.mNumRows); + assertEquals("5 key R2 left", 3, params.mLeftKeys); + assertEquals("5 key R2 right", 2, params.mRightKeys); + assertEquals("5 key R2 [1]", 0, params.getColumnPos(0)); + assertEquals("5 key R2 [2]", 1, params.getColumnPos(1)); + assertEquals("5 key R2 [3]", -1, params.getColumnPos(2)); + assertEquals("5 key R2 [4]", -2, params.getColumnPos(3)); + assertEquals("5 key R2 [5]", -3, params.getColumnPos(4)); + assertEquals("5 key R2 adjust", 0, params.mTopRowAdjustment); + assertEquals("5 key R2 default", WIDTH * 3, params.getDefaultKeyCoordX()); + } + + // [6] [4] [5] + // [3] [1] [2] + public void testLayout6KeyM0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(6, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_M0, KEYBOARD_WIDTH); + assertEquals("6 key columns", 3, params.mNumColumns); + assertEquals("6 key rows", 2, params.mNumRows); + assertEquals("6 key left", 1, params.mLeftKeys); + assertEquals("6 key right", 2, params.mRightKeys); + assertEquals("6 key [1]", 0, params.getColumnPos(0)); + assertEquals("6 key [2]", 1, params.getColumnPos(1)); + assertEquals("6 key [3]", -1, params.getColumnPos(2)); + assertEquals("6 key [4]", 0, params.getColumnPos(3)); + assertEquals("6 key [5]", 1, params.getColumnPos(4)); + assertEquals("6 key [6]", -1, params.getColumnPos(5)); + assertEquals("6 key adjust", 0, params.mTopRowAdjustment); + assertEquals("6 key default", WIDTH * 1, params.getDefaultKeyCoordX()); + } + + // |[4] [5] [6] + // |[1] [2] [3] + public void testLayout6KeyL0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(6, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L0, KEYBOARD_WIDTH); + assertEquals("6 key L0 columns", 3, params.mNumColumns); + assertEquals("6 key L0 rows", 2, params.mNumRows); + assertEquals("6 key L0 left", 0, params.mLeftKeys); + assertEquals("6 key L0 right", 3, params.mRightKeys); + assertEquals("6 key L0 [1]", 0, params.getColumnPos(0)); + assertEquals("6 key L0 [2]", 1, params.getColumnPos(1)); + assertEquals("6 key L0 [3]", 2, params.getColumnPos(2)); + assertEquals("6 key L0 [4]", 0, params.getColumnPos(3)); + assertEquals("6 key L0 [5]", 1, params.getColumnPos(4)); + assertEquals("6 key L0 [6]", 2, params.getColumnPos(5)); + assertEquals("6 key L0 adjust", 0, params.mTopRowAdjustment); + assertEquals("6 key L0 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // |___ [4] [5] [6] + // |___ [1] [2] [3] + public void testLayout6KeyL1() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(6, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L1, KEYBOARD_WIDTH); + assertEquals("6 key L1 columns", 3, params.mNumColumns); + assertEquals("6 key L1 rows", 2, params.mNumRows); + assertEquals("6 key L1 left", 0, params.mLeftKeys); + assertEquals("6 key L1 right", 3, params.mRightKeys); + assertEquals("6 key L1 [1]", 0, params.getColumnPos(0)); + assertEquals("6 key L1 [2]", 1, params.getColumnPos(1)); + assertEquals("6 key L1 [3]", 2, params.getColumnPos(2)); + assertEquals("6 key L1 [4]", 0, params.getColumnPos(3)); + assertEquals("6 key L1 [5]", 1, params.getColumnPos(4)); + assertEquals("6 key L1 [6]", 2, params.getColumnPos(5)); + assertEquals("6 key L1 adjust", 0, params.mTopRowAdjustment); + assertEquals("6 key L1 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // |___ ___ [6] [4] [5] + // |___ ___ [3] [1] [2] + public void testLayout6KeyL2() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(6, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L2, KEYBOARD_WIDTH); + assertEquals("6 key L2 columns", 3, params.mNumColumns); + assertEquals("6 key L2 rows", 2, params.mNumRows); + assertEquals("6 key L2 left", 1, params.mLeftKeys); + assertEquals("6 key L2 right", 2, params.mRightKeys); + assertEquals("6 key L2 [1]", 0, params.getColumnPos(0)); + assertEquals("6 key L2 [2]", 1, params.getColumnPos(1)); + assertEquals("6 key L2 [3]", -1, params.getColumnPos(2)); + assertEquals("6 key L2 [4]", 0, params.getColumnPos(3)); + assertEquals("6 key L2 [5]", 1, params.getColumnPos(4)); + assertEquals("6 key L2 [6]", -1, params.getColumnPos(5)); + assertEquals("6 key L2 adjust", 0, params.mTopRowAdjustment); + assertEquals("6 key L2 default", WIDTH * 1, params.getDefaultKeyCoordX()); + } + + // [6] [5] [4]| + // [3] [2] [1]| + public void testLayout6KeyR0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(6, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R0, KEYBOARD_WIDTH); + assertEquals("6 key R0 columns", 3, params.mNumColumns); + assertEquals("6 key R0 rows", 2, params.mNumRows); + assertEquals("6 key R0 left", 2, params.mLeftKeys); + assertEquals("6 key R0 right", 1, params.mRightKeys); + assertEquals("6 key R0 [1]", 0, params.getColumnPos(0)); + assertEquals("6 key R0 [2]", -1, params.getColumnPos(1)); + assertEquals("6 key R0 [3]", -2, params.getColumnPos(2)); + assertEquals("6 key R0 [4]", 0, params.getColumnPos(3)); + assertEquals("6 key R0 [5]", -1, params.getColumnPos(4)); + assertEquals("6 key R0 [6]", -2, params.getColumnPos(5)); + assertEquals("6 key R0 adjust", 0, params.mTopRowAdjustment); + assertEquals("6 key R0 default", WIDTH * 2, params.getDefaultKeyCoordX()); + } + + // [6] [5] [4] ___| + // [3] [2] [1] ___| + public void testLayout6KeyR1() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(6, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R1, KEYBOARD_WIDTH); + assertEquals("6 key R1 columns", 3, params.mNumColumns); + assertEquals("6 key R1 rows", 2, params.mNumRows); + assertEquals("6 key R1 left", 2, params.mLeftKeys); + assertEquals("6 key R1 right", 1, params.mRightKeys); + assertEquals("6 key R1 [1]", 0, params.getColumnPos(0)); + assertEquals("6 key R1 [2]", -1, params.getColumnPos(1)); + assertEquals("6 key R1 [3]", -2, params.getColumnPos(2)); + assertEquals("6 key R1 [4]", 0, params.getColumnPos(3)); + assertEquals("6 key R1 [5]", -1, params.getColumnPos(4)); + assertEquals("6 key R1 [6]", -2, params.getColumnPos(5)); + assertEquals("6 key R1 adjust", 0, params.mTopRowAdjustment); + assertEquals("6 key R1 default", WIDTH * 2, params.getDefaultKeyCoordX()); + } + + // [6] [4] [5] ___ ___| + // [3] [1] [2] ___ ___| + public void testLayout6KeyR2() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(6, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R2, KEYBOARD_WIDTH); + assertEquals("6 key R2 columns", 3, params.mNumColumns); + assertEquals("6 key R2 rows", 2, params.mNumRows); + assertEquals("6 key R2 left", 1, params.mLeftKeys); + assertEquals("6 key R2 right", 2, params.mRightKeys); + assertEquals("6 key R2 [1]", 0, params.getColumnPos(0)); + assertEquals("6 key R2 [2]", 1, params.getColumnPos(1)); + assertEquals("6 key R2 [3]", -1, params.getColumnPos(2)); + assertEquals("6 key R2 [4]", 0, params.getColumnPos(3)); + assertEquals("6 key R2 [5]", 1, params.getColumnPos(4)); + assertEquals("6 key R2 [6]", -1, params.getColumnPos(5)); + assertEquals("6 key R2 adjust", 0, params.mTopRowAdjustment); + assertEquals("6 key R2 default", WIDTH * 1, params.getDefaultKeyCoordX()); + } + + // [7] [5] [6] + // [3] [1] [2] [4] + public void testLayout7KeyM0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(7, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_M0, KEYBOARD_WIDTH); + assertEquals("7 key columns", 4, params.mNumColumns); + assertEquals("7 key rows", 2, params.mNumRows); + assertEquals("7 key left", 1, params.mLeftKeys); + assertEquals("7 key right", 3, params.mRightKeys); + assertEquals("7 key [1]", 0, params.getColumnPos(0)); + assertEquals("7 key [2]", 1, params.getColumnPos(1)); + assertEquals("7 key [3]", -1, params.getColumnPos(2)); + assertEquals("7 key [4]", 2, params.getColumnPos(3)); + assertEquals("7 key [5]", 0, params.getColumnPos(4)); + assertEquals("7 key [6]", 1, params.getColumnPos(5)); + assertEquals("7 key [7]", -1, params.getColumnPos(6)); + assertEquals("7 key adjust", 1, params.mTopRowAdjustment); + assertEquals("7 key default", WIDTH * 1, params.getDefaultKeyCoordX()); + } + + // |[5] [6] [7] + // |[1] [2] [3] [4] + public void testLayout7KeyL0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(7, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L0, KEYBOARD_WIDTH); + assertEquals("7 key L0 columns", 4, params.mNumColumns); + assertEquals("7 key L0 rows", 2, params.mNumRows); + assertEquals("7 key L0 left", 0, params.mLeftKeys); + assertEquals("7 key L0 right", 4, params.mRightKeys); + assertEquals("7 key L0 [1]", 0, params.getColumnPos(0)); + assertEquals("7 key L0 [2]", 1, params.getColumnPos(1)); + assertEquals("7 key L0 [3]", 2, params.getColumnPos(2)); + assertEquals("7 key L0 [4]", 3, params.getColumnPos(3)); + assertEquals("7 key L0 [5]", 0, params.getColumnPos(4)); + assertEquals("7 key L0 [6]", 1, params.getColumnPos(5)); + assertEquals("7 key L0 [7]", 2, params.getColumnPos(6)); + assertEquals("7 key L0 adjust", 0, params.mTopRowAdjustment); + assertEquals("7 key L0 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // |___ [5] [6] [7] + // |___ [1] [2] [3] [4] + public void testLayout7KeyL1() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(7, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L1, KEYBOARD_WIDTH); + assertEquals("7 key L1 columns", 4, params.mNumColumns); + assertEquals("7 key L1 rows", 2, params.mNumRows); + assertEquals("7 key L1 left", 0, params.mLeftKeys); + assertEquals("7 key L1 right", 4, params.mRightKeys); + assertEquals("7 key L1 [1]", 0, params.getColumnPos(0)); + assertEquals("7 key L1 [2]", 1, params.getColumnPos(1)); + assertEquals("7 key L1 [3]", 2, params.getColumnPos(2)); + assertEquals("7 key L1 [4]", 3, params.getColumnPos(3)); + assertEquals("7 key L1 [5]", 0, params.getColumnPos(4)); + assertEquals("7 key L1 [6]", 1, params.getColumnPos(5)); + assertEquals("7 key L1 [7]", 2, params.getColumnPos(6)); + assertEquals("7 key L1 adjust", 0, params.mTopRowAdjustment); + assertEquals("7 key L1 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // |___ ___ [7] [5] [6] + // |___ ___ [3] [1] [2] [4] + public void testLayout7KeyL2() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(7, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L2, KEYBOARD_WIDTH); + assertEquals("7 key L2 columns", 4, params.mNumColumns); + assertEquals("7 key L2 rows", 2, params.mNumRows); + assertEquals("7 key L2 left", 1, params.mLeftKeys); + assertEquals("7 key L2 right", 3, params.mRightKeys); + assertEquals("7 key L2 [1]", 0, params.getColumnPos(0)); + assertEquals("7 key L2 [2]", 1, params.getColumnPos(1)); + assertEquals("7 key L2 [3]", -1, params.getColumnPos(2)); + assertEquals("7 key L2 [4]", 2, params.getColumnPos(3)); + assertEquals("7 key L2 [5]", 0, params.getColumnPos(4)); + assertEquals("7 key L2 [6]", 1, params.getColumnPos(5)); + assertEquals("7 key L2 [7]", -1, params.getColumnPos(6)); + assertEquals("7 key L2 adjust", 1, params.mTopRowAdjustment); + assertEquals("7 key L2 default", WIDTH * 1, params.getDefaultKeyCoordX()); + } + + // [7] [6] [5]| + // [4] [3] [2] [1]| + public void testLayout7KeyR0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(7, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R0, KEYBOARD_WIDTH); + assertEquals("7 key R0 columns", 4, params.mNumColumns); + assertEquals("7 key R0 rows", 2, params.mNumRows); + assertEquals("7 key R0 left", 3, params.mLeftKeys); + assertEquals("7 key R0 right", 1, params.mRightKeys); + assertEquals("7 key R0 [1]", 0, params.getColumnPos(0)); + assertEquals("7 key R0 [2]", -1, params.getColumnPos(1)); + assertEquals("7 key R0 [3]", -2, params.getColumnPos(2)); + assertEquals("7 key R0 [4]", -3, params.getColumnPos(3)); + assertEquals("7 key R0 [5]", 0, params.getColumnPos(4)); + assertEquals("7 key R0 [6]", -1, params.getColumnPos(5)); + assertEquals("7 key R0 [7]", -2, params.getColumnPos(6)); + assertEquals("7 key R0 adjust", 0, params.mTopRowAdjustment); + assertEquals("7 key R0 default", WIDTH * 3, params.getDefaultKeyCoordX()); + } + + // [7] [6] [5] ___| + // [4] [3] [2] [1] ___| + public void testLayout7KeyR1() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(7, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R1, KEYBOARD_WIDTH); + assertEquals("7 key R1 columns", 4, params.mNumColumns); + assertEquals("7 key R1 rows", 2, params.mNumRows); + assertEquals("7 key R1 left", 3, params.mLeftKeys); + assertEquals("7 key R1 right", 1, params.mRightKeys); + assertEquals("7 key R1 [1]", 0, params.getColumnPos(0)); + assertEquals("7 key R1 [2]", -1, params.getColumnPos(1)); + assertEquals("7 key R1 [3]", -2, params.getColumnPos(2)); + assertEquals("7 key R1 [4]", -3, params.getColumnPos(3)); + assertEquals("7 key R1 [5]", 0, params.getColumnPos(4)); + assertEquals("7 key R1 [6]", -1, params.getColumnPos(5)); + assertEquals("7 key R1 [7]", -2, params.getColumnPos(6)); + assertEquals("7 key R1 adjust", 0, params.mTopRowAdjustment); + assertEquals("7 key R1 default", WIDTH * 3, params.getDefaultKeyCoordX()); + } + + // [7] [5] [6] ___ ___| + // [4] [3] [1] [2] ___ ___| + public void testLayout7KeyR2() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(7, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R2, KEYBOARD_WIDTH); + assertEquals("7 key R2 columns", 4, params.mNumColumns); + assertEquals("7 key R2 rows", 2, params.mNumRows); + assertEquals("7 key R2 left", 2, params.mLeftKeys); + assertEquals("7 key R2 right", 2, params.mRightKeys); + assertEquals("7 key R2 [1]", 0, params.getColumnPos(0)); + assertEquals("7 key R2 [2]", 1, params.getColumnPos(1)); + assertEquals("7 key R2 [3]", -1, params.getColumnPos(2)); + assertEquals("7 key R2 [4]", -2, params.getColumnPos(3)); + assertEquals("7 key R2 [5]", 0, params.getColumnPos(4)); + assertEquals("7 key R2 [6]", 1, params.getColumnPos(5)); + assertEquals("7 key R2 [7]", -1, params.getColumnPos(6)); + assertEquals("7 key R2 adjust", -1, params.mTopRowAdjustment); + assertEquals("7 key R2 default", WIDTH * 2, params.getDefaultKeyCoordX()); + } + + // [7] [6] [5] [3] [1] [2] [4] ___| + public void testLayout7KeyR3Max7() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(7, 7, WIDTH, + HEIGHT, XPOS_R3, KEYBOARD_WIDTH); + assertEquals("7 key R2 columns", 7, params.mNumColumns); + assertEquals("7 key R2 rows", 1, params.mNumRows); + assertEquals("7 key R2 left", 4, params.mLeftKeys); + assertEquals("7 key R2 right", 3, params.mRightKeys); + assertEquals("7 key R2 [1]", 0, params.getColumnPos(0)); + assertEquals("7 key R2 [2]", 1, params.getColumnPos(1)); + assertEquals("7 key R2 [3]", -1, params.getColumnPos(2)); + assertEquals("7 key R2 [4]", 2, params.getColumnPos(3)); + assertEquals("7 key R2 [5]", -2, params.getColumnPos(4)); + assertEquals("7 key R2 [6]", -3, params.getColumnPos(5)); + assertEquals("7 key R2 [7]", -4, params.getColumnPos(6)); + assertEquals("7 key R2 adjust", 0, params.mTopRowAdjustment); + assertEquals("7 key R2 default", WIDTH * 4, params.getDefaultKeyCoordX()); + } + + // [7] [5] [6] [8] + // [3] [1] [2] [4] + public void testLayout8KeyM0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(8, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_M0, KEYBOARD_WIDTH); + assertEquals("8 key M0 columns", 4, params.mNumColumns); + assertEquals("8 key M0 rows", 2, params.mNumRows); + assertEquals("8 key M0 left", 1, params.mLeftKeys); + assertEquals("8 key M0 right", 3, params.mRightKeys); + assertEquals("8 key M0 [1]", 0, params.getColumnPos(0)); + assertEquals("8 key M0 [2]", 1, params.getColumnPos(1)); + assertEquals("8 key M0 [3]", -1, params.getColumnPos(2)); + assertEquals("8 key M0 [4]", 2, params.getColumnPos(3)); + assertEquals("8 key M0 [5]", 0, params.getColumnPos(4)); + assertEquals("8 key M0 [6]", 1, params.getColumnPos(5)); + assertEquals("8 key M0 [7]", -1, params.getColumnPos(6)); + assertEquals("8 key M0 [8]", 2, params.getColumnPos(7)); + assertEquals("8 key M0 adjust", 0, params.mTopRowAdjustment); + assertEquals("8 key M0 default", WIDTH * 1, params.getDefaultKeyCoordX()); + } + + // |[5] [6] [7] [8] + // |[1] [2] [3] [4] + public void testLayout8KeyL0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(8, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L0, KEYBOARD_WIDTH); + assertEquals("8 key L0 columns", 4, params.mNumColumns); + assertEquals("8 key L0 rows", 2, params.mNumRows); + assertEquals("8 key L0 left", 0, params.mLeftKeys); + assertEquals("8 key L0 right", 4, params.mRightKeys); + assertEquals("8 key L0 [1]", 0, params.getColumnPos(0)); + assertEquals("8 key L0 [2]", 1, params.getColumnPos(1)); + assertEquals("8 key L0 [3]", 2, params.getColumnPos(2)); + assertEquals("8 key L0 [4]", 3, params.getColumnPos(3)); + assertEquals("8 key L0 [5]", 0, params.getColumnPos(4)); + assertEquals("8 key L0 [6]", 1, params.getColumnPos(5)); + assertEquals("8 key L0 [7]", 2, params.getColumnPos(6)); + assertEquals("8 key L0 [8]", 3, params.getColumnPos(7)); + assertEquals("8 key L0 adjust", 0, params.mTopRowAdjustment); + assertEquals("8 key L0 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // |___ [5] [6] [7] [8] + // |___ [1] [2] [3] [4] + public void testLayout8KeyL1() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(8, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L1, KEYBOARD_WIDTH); + assertEquals("8 key L1 columns", 4, params.mNumColumns); + assertEquals("8 key L1 rows", 2, params.mNumRows); + assertEquals("8 key L1 left", 0, params.mLeftKeys); + assertEquals("8 key L1 right", 4, params.mRightKeys); + assertEquals("8 key L1 [1]", 0, params.getColumnPos(0)); + assertEquals("8 key L1 [2]", 1, params.getColumnPos(1)); + assertEquals("8 key L1 [3]", 2, params.getColumnPos(2)); + assertEquals("8 key L1 [4]", 3, params.getColumnPos(3)); + assertEquals("8 key L1 [5]", 0, params.getColumnPos(4)); + assertEquals("8 key L1 [6]", 1, params.getColumnPos(5)); + assertEquals("8 key L1 [7]", 2, params.getColumnPos(6)); + assertEquals("8 key L1 [8]", 3, params.getColumnPos(7)); + assertEquals("8 key L1 adjust", 0, params.mTopRowAdjustment); + assertEquals("8 key L1 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // |___ ___ [7] [5] [6] [8] + // |___ ___ [3] [1] [2] [4] + public void testLayout8KeyL2() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(8, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L2, KEYBOARD_WIDTH); + assertEquals("8 key L2 columns", 4, params.mNumColumns); + assertEquals("8 key L2 rows", 2, params.mNumRows); + assertEquals("8 key L2 left", 1, params.mLeftKeys); + assertEquals("8 key L2 right", 3, params.mRightKeys); + assertEquals("8 key L2 [1]", 0, params.getColumnPos(0)); + assertEquals("8 key L2 [2]", 1, params.getColumnPos(1)); + assertEquals("8 key L2 [3]", -1, params.getColumnPos(2)); + assertEquals("8 key L2 [4]", 2, params.getColumnPos(3)); + assertEquals("8 key L2 [5]", 0, params.getColumnPos(4)); + assertEquals("8 key L2 [6]", 1, params.getColumnPos(5)); + assertEquals("8 key L2 [7]", -1, params.getColumnPos(6)); + assertEquals("8 key L2 [8]", 2, params.getColumnPos(7)); + assertEquals("8 key L2 adjust", 0, params.mTopRowAdjustment); + assertEquals("8 key L2 default", WIDTH * 1, params.getDefaultKeyCoordX()); + } + + // [8] [7] [6] [5]| + // [4] [3] [2] [1]| + public void testLayout8KeyR0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(8, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R0, KEYBOARD_WIDTH); + assertEquals("8 key R0 columns", 4, params.mNumColumns); + assertEquals("8 key R0 rows", 2, params.mNumRows); + assertEquals("8 key R0 left", 3, params.mLeftKeys); + assertEquals("8 key R0 right", 1, params.mRightKeys); + assertEquals("8 key R0 [1]", 0, params.getColumnPos(0)); + assertEquals("8 key R0 [2]", -1, params.getColumnPos(1)); + assertEquals("8 key R0 [3]", -2, params.getColumnPos(2)); + assertEquals("8 key R0 [4]", -3, params.getColumnPos(3)); + assertEquals("8 key R0 [5]", 0, params.getColumnPos(4)); + assertEquals("8 key R0 [6]", -1, params.getColumnPos(5)); + assertEquals("8 key R0 [7]", -2, params.getColumnPos(6)); + assertEquals("8 key R0 [8]", -3, params.getColumnPos(7)); + assertEquals("8 key R0 adjust", 0, params.mTopRowAdjustment); + assertEquals("8 key R0 default", WIDTH * 3, params.getDefaultKeyCoordX()); + } + + // [8] [7] [6] [5] ___| + // [4] [3] [2] [1] ___| + public void testLayout8KeyR1() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(8, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R1, KEYBOARD_WIDTH); + assertEquals("8 key R1 columns", 4, params.mNumColumns); + assertEquals("8 key R1 rows", 2, params.mNumRows); + assertEquals("8 key R1 left", 3, params.mLeftKeys); + assertEquals("8 key R1 right", 1, params.mRightKeys); + assertEquals("8 key R1 [1]", 0, params.getColumnPos(0)); + assertEquals("8 key R1 [2]", -1, params.getColumnPos(1)); + assertEquals("8 key R1 [3]", -2, params.getColumnPos(2)); + assertEquals("8 key R1 [4]", -3, params.getColumnPos(3)); + assertEquals("8 key R1 [5]", 0, params.getColumnPos(4)); + assertEquals("8 key R1 [6]", -1, params.getColumnPos(5)); + assertEquals("8 key R1 [7]", -2, params.getColumnPos(6)); + assertEquals("8 key R1 [8]", -3, params.getColumnPos(7)); + assertEquals("8 key R1 adjust", 0, params.mTopRowAdjustment); + assertEquals("8 key R1 default", WIDTH * 3, params.getDefaultKeyCoordX()); + } + + // [8] [7] [5] [6] ___ ___| + // [4] [3] [1] [2] ___ ___| + public void testLayout8KeyR2() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(8, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R2, KEYBOARD_WIDTH); + assertEquals("8 key R2 columns", 4, params.mNumColumns); + assertEquals("8 key R2 rows", 2, params.mNumRows); + assertEquals("8 key R2 left", 2, params.mLeftKeys); + assertEquals("8 key R2 right", 2, params.mRightKeys); + assertEquals("8 key R2 [1]", 0, params.getColumnPos(0)); + assertEquals("8 key R2 [2]", 1, params.getColumnPos(1)); + assertEquals("8 key R2 [3]", -1, params.getColumnPos(2)); + assertEquals("8 key R2 [4]", -2, params.getColumnPos(3)); + assertEquals("8 key R2 [5]", 0, params.getColumnPos(4)); + assertEquals("8 key R2 [6]", 1, params.getColumnPos(5)); + assertEquals("8 key R2 [7]", -1, params.getColumnPos(6)); + assertEquals("8 key R2 [8]", -2, params.getColumnPos(7)); + assertEquals("8 key R2 adjust", 0, params.mTopRowAdjustment); + assertEquals("8 key R2 default", WIDTH * 2, params.getDefaultKeyCoordX()); + } + + // [8] [6] [7] [9] + // [5] [3] [1] [2] [4] + public void testLayout9KeyM0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(9, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_M0, KEYBOARD_WIDTH); + assertEquals("9 key M0 columns", 5, params.mNumColumns); + assertEquals("9 key M0 rows", 2, params.mNumRows); + assertEquals("9 key M0 left", 2, params.mLeftKeys); + assertEquals("9 key M0 right", 3, params.mRightKeys); + assertEquals("9 key M0 [1]", 0, params.getColumnPos(0)); + assertEquals("9 key M0 [2]", 1, params.getColumnPos(1)); + assertEquals("9 key M0 [3]", -1, params.getColumnPos(2)); + assertEquals("9 key M0 [4]", 2, params.getColumnPos(3)); + assertEquals("9 key M0 [5]", -2, params.getColumnPos(4)); + assertEquals("9 key M0 [6]", 0, params.getColumnPos(5)); + assertEquals("9 key M0 [7]", 1, params.getColumnPos(6)); + assertEquals("9 key M0 [8]", -1, params.getColumnPos(7)); + assertEquals("9 key M0 [9]", 2, params.getColumnPos(8)); + assertEquals("9 key M0 adjust", -1, params.mTopRowAdjustment); + assertEquals("9 key M0 default", WIDTH * 2, params.getDefaultKeyCoordX()); + } + + // |[6] [7] [8] [9] + // |[1] [2] [3] [4] [5] + public void testLayout9KeyL0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(9, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L0, KEYBOARD_WIDTH); + assertEquals("9 key L0 columns", 5, params.mNumColumns); + assertEquals("9 key L0 rows", 2, params.mNumRows); + assertEquals("9 key L0 left", 0, params.mLeftKeys); + assertEquals("9 key L0 right", 5, params.mRightKeys); + assertEquals("9 key L0 [1]", 0, params.getColumnPos(0)); + assertEquals("9 key L0 [2]", 1, params.getColumnPos(1)); + assertEquals("9 key L0 [3]", 2, params.getColumnPos(2)); + assertEquals("9 key L0 [4]", 3, params.getColumnPos(3)); + assertEquals("9 key L0 [5]", 4, params.getColumnPos(4)); + assertEquals("9 key L0 [6]", 0, params.getColumnPos(5)); + assertEquals("9 key L0 [7]", 1, params.getColumnPos(6)); + assertEquals("9 key L0 [8]", 2, params.getColumnPos(7)); + assertEquals("9 key L0 [9]", 3, params.getColumnPos(8)); + assertEquals("9 key L0 adjust", 0, params.mTopRowAdjustment); + assertEquals("9 key L0 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // |___ [6] [7] [8] [9] + // |___ [1] [2] [3] [4] [5] + public void testLayout9KeyL1() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(9, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L1, KEYBOARD_WIDTH); + assertEquals("9 key L1 columns", 5, params.mNumColumns); + assertEquals("9 key L1 rows", 2, params.mNumRows); + assertEquals("9 key L1 left", 0, params.mLeftKeys); + assertEquals("9 key L1 right", 5, params.mRightKeys); + assertEquals("9 key L1 [1]", 0, params.getColumnPos(0)); + assertEquals("9 key L1 [2]", 1, params.getColumnPos(1)); + assertEquals("9 key L1 [3]", 2, params.getColumnPos(2)); + assertEquals("9 key L1 [4]", 3, params.getColumnPos(3)); + assertEquals("9 key L1 [5]", 4, params.getColumnPos(4)); + assertEquals("9 key L1 [6]", 0, params.getColumnPos(5)); + assertEquals("9 key L1 [7]", 1, params.getColumnPos(6)); + assertEquals("9 key L1 [8]", 2, params.getColumnPos(7)); + assertEquals("9 key L1 [9]", 3, params.getColumnPos(8)); + assertEquals("9 key L1 adjust", 0, params.mTopRowAdjustment); + assertEquals("9 key L1 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // |___ ___ [8] [6] [7] [9] + // |___ ___ [3] [1] [2] [4] [5] + public void testLayout9KeyL2() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(9, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L2, KEYBOARD_WIDTH); + assertEquals("9 key L2 columns", 5, params.mNumColumns); + assertEquals("9 key L2 rows", 2, params.mNumRows); + assertEquals("9 key L2 left", 1, params.mLeftKeys); + assertEquals("9 key L2 right", 4, params.mRightKeys); + assertEquals("9 key L2 [1]", 0, params.getColumnPos(0)); + assertEquals("9 key L2 [2]", 1, params.getColumnPos(1)); + assertEquals("9 key L2 [3]", -1, params.getColumnPos(2)); + assertEquals("9 key L2 [4]", 2, params.getColumnPos(3)); + assertEquals("9 key L2 [5]", 3, params.getColumnPos(4)); + assertEquals("9 key L2 [6]", 0, params.getColumnPos(5)); + assertEquals("9 key L2 [7]", 1, params.getColumnPos(6)); + assertEquals("9 key L2 [8]", -1, params.getColumnPos(7)); + assertEquals("9 key L2 [9]", 2, params.getColumnPos(8)); + assertEquals("9 key L2 adjust", 1, params.mTopRowAdjustment); + assertEquals("9 key L2 default", WIDTH * 1, params.getDefaultKeyCoordX()); + } + + // [9] [8] [7] [6]| + // [5] [4] [3] [2] [1]| + public void testLayout9KeyR0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(9, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R0, KEYBOARD_WIDTH); + assertEquals("9 key R0 columns", 5, params.mNumColumns); + assertEquals("9 key R0 rows", 2, params.mNumRows); + assertEquals("9 key R0 left", 4, params.mLeftKeys); + assertEquals("9 key R0 right", 1, params.mRightKeys); + assertEquals("9 key R0 [1]", 0, params.getColumnPos(0)); + assertEquals("9 key R0 [2]", -1, params.getColumnPos(1)); + assertEquals("9 key R0 [3]", -2, params.getColumnPos(2)); + assertEquals("9 key R0 [4]", -3, params.getColumnPos(3)); + assertEquals("9 key R0 [5]", -4, params.getColumnPos(4)); + assertEquals("9 key R0 [6]", 0, params.getColumnPos(5)); + assertEquals("9 key R0 [7]", -1, params.getColumnPos(6)); + assertEquals("9 key R0 [8]", -2, params.getColumnPos(7)); + assertEquals("9 key R0 [9]", -3, params.getColumnPos(8)); + assertEquals("9 key R0 adjust", 0, params.mTopRowAdjustment); + assertEquals("9 key R0 default", WIDTH * 4, params.getDefaultKeyCoordX()); + } + + // [9] [8] [7] [6] ___| + // [5] [4] [3] [2] [1] ___| + public void testLayout9KeyR1() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(9, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R1, KEYBOARD_WIDTH); + assertEquals("9 key R1 columns", 5, params.mNumColumns); + assertEquals("9 key R1 rows", 2, params.mNumRows); + assertEquals("9 key R1 left", 4, params.mLeftKeys); + assertEquals("9 key R1 right", 1, params.mRightKeys); + assertEquals("9 key R1 [1]", 0, params.getColumnPos(0)); + assertEquals("9 key R1 [2]", -1, params.getColumnPos(1)); + assertEquals("9 key R1 [3]", -2, params.getColumnPos(2)); + assertEquals("9 key R1 [4]", -3, params.getColumnPos(3)); + assertEquals("9 key R1 [5]", -4, params.getColumnPos(4)); + assertEquals("9 key R1 [6]", 0, params.getColumnPos(5)); + assertEquals("9 key R1 [7]", -1, params.getColumnPos(6)); + assertEquals("9 key R1 [8]", -2, params.getColumnPos(7)); + assertEquals("9 key R1 [9]", -3, params.getColumnPos(8)); + assertEquals("9 key R1 adjust", 0, params.mTopRowAdjustment); + assertEquals("9 key R1 default", WIDTH * 4, params.getDefaultKeyCoordX()); + } + + // [9] [8] [6] [7] ___ ___| + // [5] [4] [3] [1] [2] ___ ___| + public void testLayout9KeyR2() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(9, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R2, KEYBOARD_WIDTH); + assertEquals("9 key R2 columns", 5, params.mNumColumns); + assertEquals("9 key R2 rows", 2, params.mNumRows); + assertEquals("9 key R2 left", 3, params.mLeftKeys); + assertEquals("9 key R2 right", 2, params.mRightKeys); + assertEquals("9 key R2 [1]", 0, params.getColumnPos(0)); + assertEquals("9 key R2 [2]", 1, params.getColumnPos(1)); + assertEquals("9 key R2 [3]", -1, params.getColumnPos(2)); + assertEquals("9 key R2 [4]", -2, params.getColumnPos(3)); + assertEquals("9 key R2 [5]", -3, params.getColumnPos(4)); + assertEquals("9 key R2 [6]", 0, params.getColumnPos(5)); + assertEquals("9 key R2 [7]", 1, params.getColumnPos(6)); + assertEquals("9 key R2 [8]", -1, params.getColumnPos(7)); + assertEquals("9 key R2 [9]", -2, params.getColumnPos(8)); + assertEquals("9 key R2 adjust", -1, params.mTopRowAdjustment); + assertEquals("9 key R2 default", WIDTH * 3, params.getDefaultKeyCoordX()); + } + + // [A] [8] [6] [7] [9] + // [5] [3] [1] [2] [4] + public void testLayout10KeyM0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(10, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_M0, KEYBOARD_WIDTH); + assertEquals("10 key M0 columns", 5, params.mNumColumns); + assertEquals("10 key M0 rows", 2, params.mNumRows); + assertEquals("10 key M0 left", 2, params.mLeftKeys); + assertEquals("10 key M0 right", 3, params.mRightKeys); + assertEquals("10 key M0 [1]", 0, params.getColumnPos(0)); + assertEquals("10 key M0 [2]", 1, params.getColumnPos(1)); + assertEquals("10 key M0 [3]", -1, params.getColumnPos(2)); + assertEquals("10 key M0 [4]", 2, params.getColumnPos(3)); + assertEquals("10 key M0 [5]", -2, params.getColumnPos(4)); + assertEquals("10 key M0 [6]", 0, params.getColumnPos(5)); + assertEquals("10 key M0 [7]", 1, params.getColumnPos(6)); + assertEquals("10 key M0 [8]", -1, params.getColumnPos(7)); + assertEquals("10 key M0 [9]", 2, params.getColumnPos(8)); + assertEquals("10 key M0 [A]", -2, params.getColumnPos(9)); + assertEquals("10 key M0 adjust", 0, params.mTopRowAdjustment); + assertEquals("10 key M0 default", WIDTH * 2, params.getDefaultKeyCoordX()); + } + + // |[6] [7] [8] [9] [A] + // |[1] [2] [3] [4] [5] + public void testLayout10KeyL0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(10, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L0, KEYBOARD_WIDTH); + assertEquals("10 key L0 columns", 5, params.mNumColumns); + assertEquals("10 key L0 rows", 2, params.mNumRows); + assertEquals("10 key L0 left", 0, params.mLeftKeys); + assertEquals("10 key L0 right", 5, params.mRightKeys); + assertEquals("10 key L0 [1]", 0, params.getColumnPos(0)); + assertEquals("10 key L0 [2]", 1, params.getColumnPos(1)); + assertEquals("10 key L0 [3]", 2, params.getColumnPos(2)); + assertEquals("10 key L0 [4]", 3, params.getColumnPos(3)); + assertEquals("10 key L0 [5]", 4, params.getColumnPos(4)); + assertEquals("10 key L0 [6]", 0, params.getColumnPos(5)); + assertEquals("10 key L0 [7]", 1, params.getColumnPos(6)); + assertEquals("10 key L0 [8]", 2, params.getColumnPos(7)); + assertEquals("10 key L0 [9]", 3, params.getColumnPos(8)); + assertEquals("10 key L0 [A]", 4, params.getColumnPos(9)); + assertEquals("10 key L0 adjust", 0, params.mTopRowAdjustment); + assertEquals("10 key L0 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // |___ [6] [7] [8] [9] [A] + // |___ [1] [2] [3] [4] [5] + public void testLayout10KeyL1() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(10, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L1, KEYBOARD_WIDTH); + assertEquals("10 key L1 columns", 5, params.mNumColumns); + assertEquals("10 key L1 rows", 2, params.mNumRows); + assertEquals("10 key L1 left", 0, params.mLeftKeys); + assertEquals("10 key L1 right", 5, params.mRightKeys); + assertEquals("10 key L1 [1]", 0, params.getColumnPos(0)); + assertEquals("10 key L1 [2]", 1, params.getColumnPos(1)); + assertEquals("10 key L1 [3]", 2, params.getColumnPos(2)); + assertEquals("10 key L1 [4]", 3, params.getColumnPos(3)); + assertEquals("10 key L1 [5]", 4, params.getColumnPos(4)); + assertEquals("10 key L1 [6]", 0, params.getColumnPos(5)); + assertEquals("10 key L1 [7]", 1, params.getColumnPos(6)); + assertEquals("10 key L1 [8]", 2, params.getColumnPos(7)); + assertEquals("10 key L1 [9]", 3, params.getColumnPos(8)); + assertEquals("10 key L1 [A]", 4, params.getColumnPos(9)); + assertEquals("10 key L1 adjust", 0, params.mTopRowAdjustment); + assertEquals("10 key L1 default", WIDTH * 0, params.getDefaultKeyCoordX()); + } + + // |___ ___ [8] [6] [7] [9] [A] + // |___ ___ [3] [1] [2] [4] [5] + public void testLayout10KeyL2() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(10, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_L2, KEYBOARD_WIDTH); + assertEquals("10 key L2 columns", 5, params.mNumColumns); + assertEquals("10 key L2 rows", 2, params.mNumRows); + assertEquals("10 key L2 left", 1, params.mLeftKeys); + assertEquals("10 key L2 right", 4, params.mRightKeys); + assertEquals("10 key L2 [1]", 0, params.getColumnPos(0)); + assertEquals("10 key L2 [2]", 1, params.getColumnPos(1)); + assertEquals("10 key L2 [3]", -1, params.getColumnPos(2)); + assertEquals("10 key L2 [4]", 2, params.getColumnPos(3)); + assertEquals("10 key L2 [5]", 3, params.getColumnPos(4)); + assertEquals("10 key L2 [6]", 0, params.getColumnPos(5)); + assertEquals("10 key L2 [7]", 1, params.getColumnPos(6)); + assertEquals("10 key L2 [8]", -1, params.getColumnPos(7)); + assertEquals("10 key L2 [9]", 2, params.getColumnPos(8)); + assertEquals("10 key L2 [A]", 3, params.getColumnPos(9)); + assertEquals("10 key L2 adjust", 0, params.mTopRowAdjustment); + assertEquals("10 key L2 default", WIDTH * 1, params.getDefaultKeyCoordX()); + } + + // [A] [9] [8] [7] [6]| + // [5] [4] [3] [2] [1]| + public void testLayout10KeyR0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(10, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R0, KEYBOARD_WIDTH); + assertEquals("10 key R0 columns", 5, params.mNumColumns); + assertEquals("10 key R0 rows", 2, params.mNumRows); + assertEquals("10 key R0 left", 4, params.mLeftKeys); + assertEquals("10 key R0 right", 1, params.mRightKeys); + assertEquals("10 key R0 [1]", 0, params.getColumnPos(0)); + assertEquals("10 key R0 [2]", -1, params.getColumnPos(1)); + assertEquals("10 key R0 [3]", -2, params.getColumnPos(2)); + assertEquals("10 key R0 [4]", -3, params.getColumnPos(3)); + assertEquals("10 key R0 [5]", -4, params.getColumnPos(4)); + assertEquals("10 key R0 [6]", 0, params.getColumnPos(5)); + assertEquals("10 key R0 [7]", -1, params.getColumnPos(6)); + assertEquals("10 key R0 [8]", -2, params.getColumnPos(7)); + assertEquals("10 key R0 [9]", -3, params.getColumnPos(8)); + assertEquals("10 key R0 [A]", -4, params.getColumnPos(9)); + assertEquals("10 key R0 adjust", 0, params.mTopRowAdjustment); + assertEquals("10 key R0 default", WIDTH * 4, params.getDefaultKeyCoordX()); + } + + // [A] [9] [8] [7] [6] ___| + // [5] [4] [3] [2] [1] ___| + public void testLayout10KeyR1() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(10, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R1, KEYBOARD_WIDTH); + assertEquals("10 key R1 columns", 5, params.mNumColumns); + assertEquals("10 key R1 rows", 2, params.mNumRows); + assertEquals("10 key R1 left", 4, params.mLeftKeys); + assertEquals("10 key R1 right", 1, params.mRightKeys); + assertEquals("10 key R1 [1]", 0, params.getColumnPos(0)); + assertEquals("10 key R1 [2]", -1, params.getColumnPos(1)); + assertEquals("10 key R1 [3]", -2, params.getColumnPos(2)); + assertEquals("10 key R1 [4]", -3, params.getColumnPos(3)); + assertEquals("10 key R1 [5]", -4, params.getColumnPos(4)); + assertEquals("10 key R1 [6]", 0, params.getColumnPos(5)); + assertEquals("10 key R1 [7]", -1, params.getColumnPos(6)); + assertEquals("10 key R1 [8]", -2, params.getColumnPos(7)); + assertEquals("10 key R1 [9]", -3, params.getColumnPos(8)); + assertEquals("10 key R1 [A]", -4, params.getColumnPos(9)); + assertEquals("10 key R1 adjust", 0, params.mTopRowAdjustment); + assertEquals("10 key R1 default", WIDTH * 4, params.getDefaultKeyCoordX()); + } + + // [A] [9] [8] [6] [7] ___ ___| + // [5] [4] [3] [1] [2] ___ ___| + public void testLayout10KeyR2() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(10, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_R2, KEYBOARD_WIDTH); + assertEquals("10 key R2 columns", 5, params.mNumColumns); + assertEquals("10 key R2 rows", 2, params.mNumRows); + assertEquals("10 key R2 left", 3, params.mLeftKeys); + assertEquals("10 key R2 right", 2, params.mRightKeys); + assertEquals("10 key R2 [1]", 0, params.getColumnPos(0)); + assertEquals("10 key R2 [2]", 1, params.getColumnPos(1)); + assertEquals("10 key R2 [3]", -1, params.getColumnPos(2)); + assertEquals("10 key R2 [4]", -2, params.getColumnPos(3)); + assertEquals("10 key R2 [5]", -3, params.getColumnPos(4)); + assertEquals("10 key R2 [6]", 0, params.getColumnPos(5)); + assertEquals("10 key R2 [7]", 1, params.getColumnPos(6)); + assertEquals("10 key R2 [8]", -1, params.getColumnPos(7)); + assertEquals("10 key R2 [9]", -2, params.getColumnPos(8)); + assertEquals("10 key R2 [A]", -3, params.getColumnPos(9)); + assertEquals("10 key R2 adjust", 0, params.mTopRowAdjustment); + assertEquals("10 key R2 default", WIDTH * 3, params.getDefaultKeyCoordX()); + } + + // [B] [9] [A] + // [7] [5] [6] [8] + // [3] [1] [2] [4] + public void testLayout11KeyM0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(11, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_M0, KEYBOARD_WIDTH); + assertEquals("11 key M0 columns", 4, params.mNumColumns); + assertEquals("11 key M0 rows", 3, params.mNumRows); + assertEquals("11 key M0 left", 1, params.mLeftKeys); + assertEquals("11 key M0 right", 3, params.mRightKeys); + assertEquals("11 key M0 [1]", 0, params.getColumnPos(0)); + assertEquals("11 key M0 [2]", 1, params.getColumnPos(1)); + assertEquals("11 key M0 [3]", -1, params.getColumnPos(2)); + assertEquals("11 key M0 [4]", 2, params.getColumnPos(3)); + assertEquals("11 key M0 [5]", 0, params.getColumnPos(4)); + assertEquals("11 key M0 [6]", 1, params.getColumnPos(5)); + assertEquals("11 key M0 [7]", -1, params.getColumnPos(6)); + assertEquals("11 key M0 [8]", 2, params.getColumnPos(7)); + assertEquals("11 key M0 [9]", 0, params.getColumnPos(8)); + assertEquals("11 key M0 [A]", 1, params.getColumnPos(9)); + assertEquals("11 key M0 [B]", -1, params.getColumnPos(10)); + assertEquals("11 key M0 adjust", 1, params.mTopRowAdjustment); + assertEquals("11 key M0 default", WIDTH * 1, params.getDefaultKeyCoordX()); + } + + // [B] [9] [A] [C] + // [7] [5] [6] [8] + // [3] [1] [2] [4] + public void testLayout12KeyM0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(12, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_M0, KEYBOARD_WIDTH); + assertEquals("12 key M0 columns", 4, params.mNumColumns); + assertEquals("12 key M0 rows", 3, params.mNumRows); + assertEquals("12 key M0 left", 1, params.mLeftKeys); + assertEquals("12 key M0 right", 3, params.mRightKeys); + assertEquals("12 key M0 [1]", 0, params.getColumnPos(0)); + assertEquals("12 key M0 [2]", 1, params.getColumnPos(1)); + assertEquals("12 key M0 [3]", -1, params.getColumnPos(2)); + assertEquals("12 key M0 [4]", 2, params.getColumnPos(3)); + assertEquals("12 key M0 [5]", 0, params.getColumnPos(4)); + assertEquals("12 key M0 [6]", 1, params.getColumnPos(5)); + assertEquals("12 key M0 [7]", -1, params.getColumnPos(6)); + assertEquals("12 key M0 [8]", 2, params.getColumnPos(7)); + assertEquals("12 key M0 [9]", 0, params.getColumnPos(8)); + assertEquals("12 key M0 [A]", 1, params.getColumnPos(9)); + assertEquals("12 key M0 [B]", -1, params.getColumnPos(10)); + assertEquals("12 key M0 [C]", 2, params.getColumnPos(11)); + assertEquals("12 key M0 adjust", 0, params.mTopRowAdjustment); + assertEquals("12 key M0 default", WIDTH * 1, params.getDefaultKeyCoordX()); + } + + + // [D] [B] [C] + // [A] [8] [6] [7] [9] + // [5] [3] [1] [2] [4] + public void testLayout13KeyM0() { + MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams(13, MAX_COLUMNS, WIDTH, + HEIGHT, XPOS_M0, KEYBOARD_WIDTH); + assertEquals("13 key M0 columns", 5, params.mNumColumns); + assertEquals("13 key M0 rows", 3, params.mNumRows); + assertEquals("13 key M0 left", 2, params.mLeftKeys); + assertEquals("13 key M0 right", 3, params.mRightKeys); + assertEquals("13 key M0 [1]", 0, params.getColumnPos(0)); + assertEquals("13 key M0 [2]", 1, params.getColumnPos(1)); + assertEquals("13 key M0 [3]", -1, params.getColumnPos(2)); + assertEquals("13 key M0 [4]", 2, params.getColumnPos(3)); + assertEquals("13 key M0 [5]", -2, params.getColumnPos(4)); + assertEquals("13 key M0 [6]", 0, params.getColumnPos(5)); + assertEquals("13 key M0 [7]", 1, params.getColumnPos(6)); + assertEquals("13 key M0 [8]", -1, params.getColumnPos(7)); + assertEquals("13 key M0 [9]", 2, params.getColumnPos(8)); + assertEquals("13 key M0 [A]", -2, params.getColumnPos(9)); + assertEquals("13 key M0 [B]", 0, params.getColumnPos(10)); + assertEquals("13 key M0 [C]", 1, params.getColumnPos(11)); + assertEquals("13 key M0 [D]", -1, params.getColumnPos(12)); + assertEquals("13 key M0 adjust", 0, params.mTopRowAdjustment); + assertEquals("13 key M0 default", WIDTH * 2, params.getDefaultKeyCoordX()); + } +} diff --git a/tests/src/com/android/inputmethod/keyboard/internal/PopupCharactersParserTests.java b/tests/src/com/android/inputmethod/keyboard/internal/PopupCharactersParserTests.java new file mode 100644 index 000000000..e4a1c68d8 --- /dev/null +++ b/tests/src/com/android/inputmethod/keyboard/internal/PopupCharactersParserTests.java @@ -0,0 +1,220 @@ +/* + * Copyright (C) 2010 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.content.res.Resources; +import android.test.AndroidTestCase; + +import com.android.inputmethod.keyboard.Keyboard; +import com.android.inputmethod.latin.R; + +public class PopupCharactersParserTests extends AndroidTestCase { + private Resources mRes; + + private static final int ICON_SETTINGS_KEY = 5; + 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 CODE_NON_EXISTING = "@integer/non_existing"; + private static final String ICON_NON_EXISTING = "@icon/non_existing"; + + private int mCodeSettings; + + @Override + protected void setUp() { + Resources res = getContext().getResources(); + mRes = res; + + final String packageName = res.getResourcePackageName(R.string.english_ime_name); + final int codeId = res.getIdentifier(CODE_SETTINGS.substring(1), null, packageName); + mCodeSettings = res.getInteger(codeId); + } + + private void assertParser(String message, String popupSpec, String expectedLabel, + String expectedOutputText, int expectedIcon, int expectedCode) { + String actualLabel = PopupCharactersParser.getLabel(popupSpec); + assertEquals(message + ": label:", expectedLabel, actualLabel); + + String actualOutputText = PopupCharactersParser.getOutputText(popupSpec); + assertEquals(message + ": ouptputText:", expectedOutputText, actualOutputText); + + int actualIcon = PopupCharactersParser.getIconId(popupSpec); + assertEquals(message + ": icon:", expectedIcon, actualIcon); + + int actualCode = PopupCharactersParser.getCode(mRes, popupSpec); + assertEquals(message + ": codes value:", expectedCode, actualCode); + } + + private void assertParserError(String message, String popupSpec, String expectedLabel, + String expectedOutputText, int expectedIcon, int expectedCode) { + try { + assertParser(message, popupSpec, expectedLabel, expectedOutputText, expectedIcon, + expectedCode); + fail(message); + } catch (PopupCharactersParser.PopupCharactersParserError pcpe) { + // success. + } + } + + public void testSingleLetter() { + assertParser("Single letter", "a", + "a", null, ICON_UNDEFINED, 'a'); + assertParser("Single escaped bar", "\\|", + "|", null, ICON_UNDEFINED, '|'); + assertParser("Single escaped escape", "\\\\", + "\\", null, ICON_UNDEFINED, '\\'); + assertParser("Single comma", ",", + ",", null, ICON_UNDEFINED, ','); + assertParser("Single escaped comma", "\\,", + ",", null, ICON_UNDEFINED, ','); + assertParser("Single escaped letter", "\\a", + "a", null, ICON_UNDEFINED, 'a'); + assertParser("Single at", "@", + "@", null, ICON_UNDEFINED, '@'); + assertParser("Single escaped at", "\\@", + "@", null, ICON_UNDEFINED, '@'); + assertParser("Single letter with outputText", "a|abc", + "a", "abc", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Single letter with escaped outputText", "a|a\\|c", + "a", "a|c", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Single letter with comma outputText", "a|a,b", + "a", "a,b", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Single letter with escaped comma outputText", "a|a\\,b", + "a", "a,b", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Single letter with outputText starts with at", "a|@bc", + "a", "@bc", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Single letter with outputText contains at", "a|a@c", + "a", "a@c", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Single letter with escaped at outputText", "a|\\@bc", + "a", "@bc", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Single escaped escape with outputText", "\\\\|\\\\", + "\\", "\\", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Single escaped bar with outputText", "\\||\\|", + "|", "|", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + 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_DUMMY); + assertParser("Label with escaped bar", "a\\|c", + "a|c", "a|c", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Label with escaped escape", "a\\\\c", + "a\\c", "a\\c", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Label with comma", "a,c", + "a,c", "a,c", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Label with escaped comma", "a\\,c", + "a,c", "a,c", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Label starts with at", "@bc", + "@bc", "@bc", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Label contains at", "a@c", + "a@c", "a@c", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Label with escaped at", "\\@bc", + "@bc", "@bc", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Label with escaped letter", "\\abc", + "abc", "abc", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Label with outputText", "abc|def", + "abc", "def", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Label with comma and outputText", "a,c|def", + "a,c", "def", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Escaped comma label with outputText", "a\\,c|def", + "a,c", "def", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Escaped label with outputText", "a\\|c|def", + "a|c", "def", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Label with escaped bar outputText", "abc|d\\|f", + "abc", "d|f", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Escaped escape label with outputText", "a\\\\|def", + "a\\", "def", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Label starts with at and outputText", "@bc|def", + "@bc", "def", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Label contains at label and outputText", "a@c|def", + "a@c", "def", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Escaped at label with outputText", "\\@bc|def", + "@bc", "def", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Label with comma outputText", "abc|a,b", + "abc", "a,b", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Label with escaped comma outputText", "abc|a\\,b", + "abc", "a,b", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Label with outputText starts with at", "abc|@bc", + "abc", "@bc", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Label with outputText contains at", "abc|a@c", + "abc", "a@c", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Label with escaped at outputText", "abc|\\@bc", + "abc", "@bc", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Label with escaped bar outputText", "abc|d\\|f", + "abc", "d|f", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Escaped bar label with escaped bar outputText", "a\\|c|d\\|f", + "a|c", "d|f", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParser("Label with code", "abc|" + CODE_SETTINGS, + "abc", null, ICON_UNDEFINED, mCodeSettings); + assertParser("Escaped label with code", "a\\|c|" + CODE_SETTINGS, + "a|c", null, ICON_UNDEFINED, mCodeSettings); + } + + public void testIconAndCode() { + assertParser("Icon with outputText", ICON_SETTINGS + "|abc", + null, "abc", ICON_SETTINGS_KEY, Keyboard.CODE_DUMMY); + assertParser("Icon with outputText starts with at", ICON_SETTINGS + "|@bc", + null, "@bc", ICON_SETTINGS_KEY, Keyboard.CODE_DUMMY); + assertParser("Icon with outputText contains at", ICON_SETTINGS + "|a@c", + null, "a@c", ICON_SETTINGS_KEY, Keyboard.CODE_DUMMY); + assertParser("Icon with escaped at outputText", ICON_SETTINGS + "|\\@bc", + null, "@bc", ICON_SETTINGS_KEY, Keyboard.CODE_DUMMY); + 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, + "a@c", null, ICON_UNDEFINED, mCodeSettings); + assertParser("Escaped at label with code", "\\@bc|" + CODE_SETTINGS, + "@bc", null, ICON_UNDEFINED, mCodeSettings); + assertParser("Icon with code", ICON_SETTINGS + "|" + CODE_SETTINGS, + null, null, ICON_SETTINGS_KEY, mCodeSettings); + } + + public void testFormatError() { + assertParserError("Empty spec", "", null, + null, ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + assertParserError("Empty label with outputText", "|a", + null, "a", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParserError("Empty label with code", "|" + CODE_SETTINGS, + null, null, ICON_UNDEFINED, mCodeSettings); + assertParserError("Empty outputText with label", "a|", + "a", null, ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + assertParserError("Empty outputText with icon", ICON_SETTINGS + "|", + null, null, ICON_SETTINGS_KEY, Keyboard.CODE_UNSPECIFIED); + assertParserError("Empty icon and code", "|", + null, null, ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + assertParserError("Icon without code", ICON_SETTINGS, + null, null, ICON_SETTINGS_KEY, Keyboard.CODE_DUMMY); + assertParser("Non existing icon", ICON_NON_EXISTING + "|abc", + null, "abc", ICON_UNDEFINED, Keyboard.CODE_DUMMY); + assertParserError("Non existing code", "abc|" + CODE_NON_EXISTING, + "abc", null, ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + assertParserError("Third bar at end", "a|b|", + "a", null, ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + assertParserError("Multiple bar", "a|b|c", + "a", null, ICON_UNDEFINED, Keyboard.CODE_UNSPECIFIED); + assertParserError("Multiple bar with label and code", "a|" + CODE_SETTINGS + "|c", + "a", null, ICON_UNDEFINED, mCodeSettings); + assertParserError("Multiple bar with icon and outputText", ICON_SETTINGS + "|b|c", + null, null, ICON_SETTINGS_KEY, Keyboard.CODE_UNSPECIFIED); + assertParserError("Multiple bar with icon and code", + ICON_SETTINGS + "|" + CODE_SETTINGS + "|c", + null, null, ICON_SETTINGS_KEY, mCodeSettings); + } +} diff --git a/tests/src/com/android/inputmethod/latin/EditDistanceTests.java b/tests/src/com/android/inputmethod/latin/EditDistanceTests.java new file mode 100644 index 000000000..75bd04938 --- /dev/null +++ b/tests/src/com/android/inputmethod/latin/EditDistanceTests.java @@ -0,0 +1,107 @@ +/* + * Copyright (C) 2010 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.test.AndroidTestCase; + +public class EditDistanceTests extends AndroidTestCase { + @Override + protected void setUp() throws Exception { + super.setUp(); + } + + @Override + protected void tearDown() throws Exception { + super.tearDown(); + } + + /* + * dist(kitten, sitting) == 3 + * + * kitten- + * .|||.| + * sitting + */ + public void testExample1() { + final int dist = Utils.editDistance("kitten", "sitting"); + assertEquals("edit distance between 'kitten' and 'sitting' is 3", + 3, dist); + } + + /* + * dist(Sunday, Saturday) == 3 + * + * Saturday + * | |.||| + * S--unday + */ + public void testExample2() { + final int dist = Utils.editDistance("Saturday", "Sunday"); + assertEquals("edit distance between 'Saturday' and 'Sunday' is 3", + 3, dist); + } + + public void testBothEmpty() { + final int dist = Utils.editDistance("", ""); + assertEquals("when both string are empty, no edits are needed", + 0, dist); + } + + public void testFirstArgIsEmpty() { + final int dist = Utils.editDistance("", "aaaa"); + assertEquals("when only one string of the arguments is empty," + + " the edit distance is the length of the other.", + 4, dist); + } + + public void testSecoondArgIsEmpty() { + final int dist = Utils.editDistance("aaaa", ""); + assertEquals("when only one string of the arguments is empty," + + " the edit distance is the length of the other.", + 4, dist); + } + + public void testSameStrings() { + final String arg1 = "The quick brown fox jumps over the lazy dog."; + final String arg2 = "The quick brown fox jumps over the lazy dog."; + final int dist = Utils.editDistance(arg1, arg2); + assertEquals("when same strings are passed, distance equals 0.", + 0, dist); + } + + public void testSameReference() { + final String arg = "The quick brown fox jumps over the lazy dog."; + final int dist = Utils.editDistance(arg, arg); + assertEquals("when same string references are passed, the distance equals 0.", + 0, dist); + } + + public void testNullArg() { + try { + Utils.editDistance(null, "aaa"); + fail("IllegalArgumentException should be thrown."); + } catch (Exception e) { + assertTrue(e instanceof IllegalArgumentException); + } + try { + Utils.editDistance("aaa", null); + fail("IllegalArgumentException should be thrown."); + } catch (Exception e) { + assertTrue(e instanceof IllegalArgumentException); + } + } +} diff --git a/tests/src/com/android/inputmethod/latin/EventRingBufferTests.java b/tests/src/com/android/inputmethod/latin/EventRingBufferTests.java index 620f036db..a3d2a2b10 100644 --- a/tests/src/com/android/inputmethod/latin/EventRingBufferTests.java +++ b/tests/src/com/android/inputmethod/latin/EventRingBufferTests.java @@ -16,7 +16,7 @@ package com.android.inputmethod.latin; -import com.android.inputmethod.latin.SwipeTracker.EventRingBuffer; +import com.android.inputmethod.keyboard.internal.SwipeTracker.EventRingBuffer; import android.test.AndroidTestCase; diff --git a/tests/src/com/android/inputmethod/latin/SubtypeLocaleTests.java b/tests/src/com/android/inputmethod/latin/SubtypeLocaleTests.java new file mode 100644 index 000000000..d102aa4d1 --- /dev/null +++ b/tests/src/com/android/inputmethod/latin/SubtypeLocaleTests.java @@ -0,0 +1,96 @@ +/* + * 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; + +import com.android.inputmethod.latin.Utils; + +import android.content.Context; +import android.content.res.Resources; +import android.test.AndroidTestCase; +import android.view.inputmethod.InputMethodInfo; +import android.view.inputmethod.InputMethodManager; +import android.view.inputmethod.InputMethodSubtype; + +import java.util.ArrayList; +import java.util.List; +import java.util.Locale; + +public class SubtypeLocaleTests extends AndroidTestCase { + private static final String PACKAGE = LatinIME.class.getPackage().getName(); + + private Resources mRes; + private List<InputMethodSubtype> mKeyboardSubtypes = new ArrayList<InputMethodSubtype>(); + + @Override + protected void setUp() throws Exception { + super.setUp(); + + final Context context = getContext(); + mRes = context.getResources(); + + SubtypeLocale.init(context); + + final InputMethodManager imm = (InputMethodManager) context.getSystemService( + Context.INPUT_METHOD_SERVICE); + for (final InputMethodInfo imi : imm.getInputMethodList()) { + if (imi.getPackageName().equals(PACKAGE)) { + final int subtypeCount = imi.getSubtypeCount(); + for (int i = 0; i < subtypeCount; ++i) { + InputMethodSubtype subtype = imi.getSubtypeAt(i); + if (subtype.getMode().equals("keyboard")) { + mKeyboardSubtypes.add(subtype); + } + } + break; + } + } + assertNotNull("Can not find input method " + PACKAGE, mKeyboardSubtypes); + assertTrue("Can not find keyboard subtype", mKeyboardSubtypes.size() > 0); + } + + private String getStringWithLocale(int resId, Locale locale) { + final Locale savedLocale = Locale.getDefault(); + try { + Locale.setDefault(locale); + return mRes.getString(resId); + } finally { + Locale.setDefault(savedLocale); + } + } + + public void testSubtypeLocale() { + final StringBuilder messages = new StringBuilder(); + int failedCount = 0; + for (final InputMethodSubtype subtype : mKeyboardSubtypes) { + final String localeCode = subtype.getLocale(); + final Locale locale = Utils.constructLocaleFromString(localeCode); + // The locale name which will be displayed on spacebar. For example 'English (US)' or + // 'Francais (Canada)'. (c=\u008d) + final String displayName = SubtypeLocale.getFullDisplayName(locale); + // The subtype name in its locale. For example 'English (US) Keyboard' or + // 'Clavier Francais (Canada)'. (c=\u008d) + final String subtypeName = getStringWithLocale(subtype.getNameResId(), locale); + if (subtypeName.contains(displayName)) { + failedCount++; + messages.append(String.format( + "subtype name is '%s' and should contain locale '%s' name '%s'\n", + subtypeName, localeCode, displayName)); + } + } + assertEquals(messages.toString(), 0, failedCount); + } +} diff --git a/tests/src/com/android/inputmethod/latin/SuggestHelper.java b/tests/src/com/android/inputmethod/latin/SuggestHelper.java index 759bfa18a..87ea011fa 100644 --- a/tests/src/com/android/inputmethod/latin/SuggestHelper.java +++ b/tests/src/com/android/inputmethod/latin/SuggestHelper.java @@ -16,253 +16,146 @@ package com.android.inputmethod.latin; +import com.android.inputmethod.keyboard.Key; +import com.android.inputmethod.keyboard.KeyDetector; +import com.android.inputmethod.keyboard.KeyboardId; +import com.android.inputmethod.keyboard.LatinKeyboard; + import android.content.Context; import android.text.TextUtils; -import android.util.Log; -import com.android.inputmethod.latin.Suggest; -import com.android.inputmethod.latin.UserBigramDictionary; -import com.android.inputmethod.latin.WordComposer; -import java.io.IOException; -import java.io.InputStream; -import java.nio.ByteBuffer; -import java.nio.ByteOrder; -import java.nio.channels.Channels; +import java.io.File; import java.util.List; -import java.util.Locale; -import java.util.StringTokenizer; public class SuggestHelper { - private Suggest mSuggest; - private UserBigramDictionary mUserBigram; - private final String TAG; + protected final Suggest mSuggest; + private final LatinKeyboard mKeyboard; + private final KeyDetector mKeyDetector; - /** Uses main dictionary only **/ - public SuggestHelper(String tag, Context context, int[] resId) { - TAG = tag; - InputStream[] is = null; - try { - // merging separated dictionary into one if dictionary is separated - int total = 0; - is = new InputStream[resId.length]; - for (int i = 0; i < resId.length; i++) { - is[i] = context.getResources().openRawResource(resId[i]); - total += is[i].available(); - } + public SuggestHelper(Context context, int dictionaryId, KeyboardId keyboardId) { + // Use null as the locale for Suggest so as to force it to use the internal dictionary + // (and not try to find a dictionary provider for a specified locale) + mSuggest = new Suggest(context, dictionaryId, null); + mKeyboard = new LatinKeyboard(context, keyboardId, keyboardId.mWidth); + mKeyDetector = new KeyDetector(); + init(); + } - ByteBuffer byteBuffer = - ByteBuffer.allocateDirect(total).order(ByteOrder.nativeOrder()); - int got = 0; - for (int i = 0; i < resId.length; i++) { - got += Channels.newChannel(is[i]).read(byteBuffer); - } - if (got != total) { - Log.w(TAG, "Read " + got + " bytes, expected " + total); - } else { - mSuggest = new Suggest(context, byteBuffer); - Log.i(TAG, "Created mSuggest " + total + " bytes"); - } - } catch (IOException e) { - Log.w(TAG, "No available memory for binary dictionary"); - } finally { - try { - if (is != null) { - for (int i = 0; i < is.length; i++) { - is[i].close(); - } - } - } catch (IOException e) { - Log.w(TAG, "Failed to close input stream"); - } - } - mSuggest.setAutoTextEnabled(false); - mSuggest.setCorrectionMode(Suggest.CORRECTION_FULL_BIGRAM); + protected SuggestHelper(Context context, File dictionaryPath, long startOffset, long length, + KeyboardId keyboardId) { + mSuggest = new Suggest(context, dictionaryPath, startOffset, length, null); + mKeyboard = new LatinKeyboard(context, keyboardId, keyboardId.mWidth); + mKeyDetector = new KeyDetector(); + init(); } - /** Uses both main dictionary and user-bigram dictionary **/ - public SuggestHelper(String tag, Context context, int[] resId, int userBigramMax, - int userBigramDelete) { - this(tag, context, resId); - mUserBigram = new UserBigramDictionary(context, null, Locale.US.toString(), - Suggest.DIC_USER); - mUserBigram.setDatabaseMax(userBigramMax); - mUserBigram.setDatabaseDelete(userBigramDelete); - mSuggest.setUserBigramDictionary(mUserBigram); + private void init() { + mSuggest.setQuickFixesEnabled(false); + mSuggest.setCorrectionMode(Suggest.CORRECTION_FULL); + mKeyDetector.setKeyboard(mKeyboard, 0, 0); + mKeyDetector.setProximityCorrectionEnabled(true); + mKeyDetector.setProximityThreshold(mKeyboard.getMostCommonKeyWidth()); } - void changeUserBigramLocale(Context context, Locale locale) { - if (mUserBigram != null) { - flushUserBigrams(); - mUserBigram.close(); - mUserBigram = new UserBigramDictionary(context, null, locale.toString(), - Suggest.DIC_USER); - mSuggest.setUserBigramDictionary(mUserBigram); + public void setCorrectionMode(int correctionMode) { + mSuggest.setCorrectionMode(correctionMode); + } + + public boolean hasMainDictionary() { + return mSuggest.hasMainDictionary(); + } + + private void addKeyInfo(WordComposer word, char c) { + final List<Key> keys = mKeyboard.getKeys(); + for (final Key key : keys) { + if (key.mCode == c) { + final int x = key.mX + key.mWidth / 2; + final int y = key.mY + key.mHeight / 2; + final int[] codes = mKeyDetector.newCodeArray(); + mKeyDetector.getKeyIndexAndNearbyCodes(x, y, codes); + word.add(c, codes, x, y); + return; + } } + word.add(c, new int[] { c }, WordComposer.NOT_A_COORDINATE, WordComposer.NOT_A_COORDINATE); } - private WordComposer createWordComposer(CharSequence s) { + protected WordComposer createWordComposer(CharSequence s) { WordComposer word = new WordComposer(); for (int i = 0; i < s.length(); i++) { final char c = s.charAt(i); - int[] codes; - // If it's not a lowercase letter, don't find adjacent letters - if (c < 'a' || c > 'z') { - codes = new int[] { c }; - } else { - codes = adjacents[c - 'a']; - } - word.add(c, codes); + addKeyInfo(word, c); } return word; } - private void showList(String title, List<CharSequence> suggestions) { - Log.i(TAG, title); - for (int i = 0; i < suggestions.size(); i++) { - Log.i(title, suggestions.get(i) + ", "); - } + public boolean isValidWord(CharSequence typed) { + return AutoCorrection.isValidWordForAutoCorrection(mSuggest.getUnigramDictionaries(), + typed, false); } - private boolean isDefaultSuggestion(List<CharSequence> suggestions, CharSequence word) { - // Check if either the word is what you typed or the first alternative - return suggestions.size() > 0 && - (/*TextUtils.equals(suggestions.get(0), word) || */ - (suggestions.size() > 1 && TextUtils.equals(suggestions.get(1), word))); + // TODO: This may be slow, but is OK for test so far. + public SuggestedWords getSuggestions(CharSequence typed) { + return mSuggest.getSuggestions(null, createWordComposer(typed), null); } - boolean isDefaultSuggestion(CharSequence typed, CharSequence expected) { + public CharSequence getFirstSuggestion(CharSequence typed) { WordComposer word = createWordComposer(typed); - List<CharSequence> suggestions = mSuggest.getSuggestions(null, word, false, null); - return isDefaultSuggestion(suggestions, expected); + SuggestedWords suggestions = mSuggest.getSuggestions(null, word, null); + // Note that suggestions.getWord(0) is the word user typed. + return suggestions.size() > 1 ? suggestions.getWord(1) : null; } - boolean isDefaultCorrection(CharSequence typed, CharSequence expected) { + public CharSequence getAutoCorrection(CharSequence typed) { WordComposer word = createWordComposer(typed); - List<CharSequence> suggestions = mSuggest.getSuggestions(null, word, false, null); - return isDefaultSuggestion(suggestions, expected) && mSuggest.hasMinimalCorrection(); + SuggestedWords suggestions = mSuggest.getSuggestions(null, word, null); + // Note that suggestions.getWord(0) is the word user typed. + return (suggestions.size() > 1 && mSuggest.hasAutoCorrection()) + ? suggestions.getWord(1) : null; } - boolean isASuggestion(CharSequence typed, CharSequence expected) { + public int getSuggestIndex(CharSequence typed, CharSequence expected) { WordComposer word = createWordComposer(typed); - List<CharSequence> suggestions = mSuggest.getSuggestions(null, word, false, null); + SuggestedWords suggestions = mSuggest.getSuggestions(null, word, null); + // Note that suggestions.getWord(0) is the word user typed. for (int i = 1; i < suggestions.size(); i++) { - if (TextUtils.equals(suggestions.get(i), expected)) return true; + if (TextUtils.equals(suggestions.getWord(i), expected)) + return i; } - return false; + return -1; } private void getBigramSuggestions(CharSequence previous, CharSequence typed) { if (!TextUtils.isEmpty(previous) && (typed.length() > 1)) { WordComposer firstChar = createWordComposer(Character.toString(typed.charAt(0))); - mSuggest.getSuggestions(null, firstChar, false, previous); + mSuggest.getSuggestions(null, firstChar, previous); } } - boolean isDefaultNextSuggestion(CharSequence previous, CharSequence typed, - CharSequence expected) { + public CharSequence getBigramFirstSuggestion(CharSequence previous, CharSequence typed) { WordComposer word = createWordComposer(typed); getBigramSuggestions(previous, typed); - List<CharSequence> suggestions = mSuggest.getSuggestions(null, word, false, previous); - return isDefaultSuggestion(suggestions, expected); + SuggestedWords suggestions = mSuggest.getSuggestions(null, word, previous); + return suggestions.size() > 1 ? suggestions.getWord(1) : null; } - boolean isDefaultNextCorrection(CharSequence previous, CharSequence typed, - CharSequence expected) { + public CharSequence getBigramAutoCorrection(CharSequence previous, CharSequence typed) { WordComposer word = createWordComposer(typed); getBigramSuggestions(previous, typed); - List<CharSequence> suggestions = mSuggest.getSuggestions(null, word, false, previous); - return isDefaultSuggestion(suggestions, expected) && mSuggest.hasMinimalCorrection(); + SuggestedWords suggestions = mSuggest.getSuggestions(null, word, previous); + return (suggestions.size() > 1 && mSuggest.hasAutoCorrection()) + ? suggestions.getWord(1) : null; } - boolean isASuggestion(CharSequence previous, CharSequence typed, + public int searchBigramSuggestion(CharSequence previous, CharSequence typed, CharSequence expected) { WordComposer word = createWordComposer(typed); getBigramSuggestions(previous, typed); - List<CharSequence> suggestions = mSuggest.getSuggestions(null, word, false, previous); + SuggestedWords suggestions = mSuggest.getSuggestions(null, word, previous); for (int i = 1; i < suggestions.size(); i++) { - if (TextUtils.equals(suggestions.get(i), expected)) return true; + if (TextUtils.equals(suggestions.getWord(i), expected)) + return i; } - return false; - } - - boolean isValid(CharSequence typed) { - return mSuggest.isValidWord(typed); + return -1; } - - boolean isUserBigramSuggestion(CharSequence previous, char typed, - CharSequence expected) { - WordComposer word = createWordComposer(Character.toString(typed)); - - if (mUserBigram == null) return false; - - flushUserBigrams(); - if (!TextUtils.isEmpty(previous) && !TextUtils.isEmpty(Character.toString(typed))) { - WordComposer firstChar = createWordComposer(Character.toString(typed)); - mSuggest.getSuggestions(null, firstChar, false, previous); - boolean reloading = mUserBigram.reloadDictionaryIfRequired(); - if (reloading) mUserBigram.waitForDictionaryLoading(); - mUserBigram.getBigrams(firstChar, previous, mSuggest, null); - } - - List<CharSequence> suggestions = mSuggest.mBigramSuggestions; - for (int i = 0; i < suggestions.size(); i++) { - if (TextUtils.equals(suggestions.get(i), expected)) return true; - } - - return false; - } - - void addToUserBigram(String sentence) { - StringTokenizer st = new StringTokenizer(sentence); - String previous = null; - while (st.hasMoreTokens()) { - String current = st.nextToken(); - if (previous != null) { - addToUserBigram(new String[] {previous, current}); - } - previous = current; - } - } - - void addToUserBigram(String[] pair) { - if (mUserBigram != null && pair.length == 2) { - mUserBigram.addBigrams(pair[0], pair[1]); - } - } - - void flushUserBigrams() { - if (mUserBigram != null) { - mUserBigram.flushPendingWrites(); - mUserBigram.waitUntilUpdateDBDone(); - } - } - - final int[][] adjacents = { - {'a','s','w','q',-1}, - {'b','h','v','n','g','j',-1}, - {'c','v','f','x','g',}, - {'d','f','r','e','s','x',-1}, - {'e','w','r','s','d',-1}, - {'f','g','d','c','t','r',-1}, - {'g','h','f','y','t','v',-1}, - {'h','j','u','g','b','y',-1}, - {'i','o','u','k',-1}, - {'j','k','i','h','u','n',-1}, - {'k','l','o','j','i','m',-1}, - {'l','k','o','p',-1}, - {'m','k','n','l',-1}, - {'n','m','j','k','b',-1}, - {'o','p','i','l',-1}, - {'p','o',-1}, - {'q','w',-1}, - {'r','t','e','f',-1}, - {'s','d','e','w','a','z',-1}, - {'t','y','r',-1}, - {'u','y','i','h','j',-1}, - {'v','b','g','c','h',-1}, - {'w','e','q',-1}, - {'x','c','d','z','f',-1}, - {'y','u','t','h','g',-1}, - {'z','s','x','a','d',-1}, - }; } diff --git a/tests/src/com/android/inputmethod/latin/SuggestPerformanceTests.java b/tests/src/com/android/inputmethod/latin/SuggestPerformanceTests.java index 7eb66d502..99bcc615e 100644 --- a/tests/src/com/android/inputmethod/latin/SuggestPerformanceTests.java +++ b/tests/src/com/android/inputmethod/latin/SuggestPerformanceTests.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2010 The Android Open Source Project + * Copyright (C) 2010,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 @@ -15,70 +15,77 @@ */ package com.android.inputmethod.latin; - -import android.test.AndroidTestCase; -import android.util.Log; import com.android.inputmethod.latin.tests.R; -import java.io.InputStreamReader; -import java.io.InputStream; + +import android.content.res.AssetFileDescriptor; +import android.text.TextUtils; +import android.util.Slog; + import java.io.BufferedReader; +import java.io.InputStreamReader; +import java.util.Locale; import java.util.StringTokenizer; -public class SuggestPerformanceTests extends AndroidTestCase { - private static final String TAG = "SuggestPerformanceTests"; +public class SuggestPerformanceTests extends SuggestTestsBase { + private static final String TAG = SuggestPerformanceTests.class.getSimpleName(); private String mTestText; - private SuggestHelper sh; + private SuggestHelper mHelper; @Override - protected void setUp() { - // TODO Figure out a way to directly using the dictionary rather than copying it over - - // For testing with real dictionary, TEMPORARILY COPY main dictionary into test directory. - // DO NOT SUBMIT real dictionary under test directory. - //int[] resId = new int[] { R.raw.main0, R.raw.main1, R.raw.main2 }; - - int[] resId = new int[] { R.raw.test }; - - sh = new SuggestHelper(TAG, getTestContext(), resId); - loadString(); + protected void setUp() throws Exception { + super.setUp(); + final AssetFileDescriptor dict = openTestRawResourceFd(R.raw.test); + mHelper = new SuggestHelper( + getContext(), mTestPackageFile, dict.getStartOffset(), dict.getLength(), + createKeyboardId(Locale.US)); + loadString(R.raw.testtext); } - private void loadString() { + private void loadString(int testFileId) { + final String testFile = getTestContext().getResources().getResourceName(testFileId); + BufferedReader reader = null; try { - InputStream is = getTestContext().getResources().openRawResource(R.raw.testtext); - BufferedReader reader = new BufferedReader(new InputStreamReader(is)); - StringBuilder sb = new StringBuilder(); - String line = reader.readLine(); - while (line != null) { - sb.append(line + " "); - line = reader.readLine(); + reader = new BufferedReader( + new InputStreamReader(openTestRawResource(testFileId))); + final StringBuilder sb = new StringBuilder(); + String line; + Slog.i(TAG, "Reading test file " + testFile); + while ((line = reader.readLine()) != null) { + sb.append(line); + sb.append(" "); } mTestText = sb.toString(); } catch (Exception e) { + Slog.e(TAG, "Can not read " + testFile); e.printStackTrace(); + } finally { + if (reader != null) { + try { + reader.close(); + } catch (Exception e) { + Slog.e(TAG, "Closing " + testFile + " failed"); + } + } } } /************************** Helper functions ************************/ - private int lookForSuggestion(String prevWord, String currentWord) { + private int lookForBigramSuggestion(String prevWord, String currentWord) { for (int i = 1; i < currentWord.length(); i++) { - if (i == 1) { - if (sh.isDefaultNextSuggestion(prevWord, currentWord.substring(0, i), - currentWord)) { - return i; - } - } else { - if (sh.isDefaultNextCorrection(prevWord, currentWord.substring(0, i), - currentWord)) { - return i; - } - } + final CharSequence prefix = currentWord.substring(0, i); + final CharSequence word = (i == 1) + ? mHelper.getBigramFirstSuggestion(prevWord, prefix) + : mHelper.getBigramAutoCorrection(prevWord, prefix); + if (TextUtils.equals(word, currentWord)) + return i; } return currentWord.length(); } private double runText(boolean withBigrams) { + mHelper.setCorrectionMode( + withBigrams ? Suggest.CORRECTION_FULL_BIGRAM : Suggest.CORRECTION_FULL); StringTokenizer st = new StringTokenizer(mTestText); String prevWord = null; int typeCount = 0; @@ -92,9 +99,9 @@ public class SuggestPerformanceTests extends AndroidTestCase { endCheck = true; } if (withBigrams && prevWord != null) { - typeCount += lookForSuggestion(prevWord, currentWord); + typeCount += lookForBigramSuggestion(prevWord, currentWord); } else { - typeCount += lookForSuggestion(null, currentWord); + typeCount += lookForBigramSuggestion(null, currentWord); } characterCount += currentWord.length(); if (!endCheck) prevWord = currentWord; @@ -103,14 +110,14 @@ public class SuggestPerformanceTests extends AndroidTestCase { double result = (double) (characterCount - typeCount) / characterCount * 100; if (withBigrams) { - Log.i(TAG, "with bigrams -> " + result + " % saved!"); + Slog.i(TAG, "with bigrams -> " + result + " % saved!"); } else { - Log.i(TAG, "without bigrams -> " + result + " % saved!"); + Slog.i(TAG, "without bigrams -> " + result + " % saved!"); } - Log.i(TAG, "\ttotal number of words: " + wordCount); - Log.i(TAG, "\ttotal number of characters: " + mTestText.length()); - Log.i(TAG, "\ttotal number of characters without space: " + characterCount); - Log.i(TAG, "\ttotal number of characters typed: " + typeCount); + Slog.i(TAG, "\ttotal number of words: " + wordCount); + Slog.i(TAG, "\ttotal number of characters: " + mTestText.length()); + Slog.i(TAG, "\ttotal number of characters without space: " + characterCount); + Slog.i(TAG, "\ttotal number of characters typed: " + typeCount); return result; } diff --git a/tests/src/com/android/inputmethod/latin/SuggestTests.java b/tests/src/com/android/inputmethod/latin/SuggestTests.java index 8463ed316..6e9a12797 100644 --- a/tests/src/com/android/inputmethod/latin/SuggestTests.java +++ b/tests/src/com/android/inputmethod/latin/SuggestTests.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2010 The Android Open Source Project + * Copyright (C) 2010,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 @@ -16,18 +16,23 @@ package com.android.inputmethod.latin; -import android.test.AndroidTestCase; import com.android.inputmethod.latin.tests.R; -public class SuggestTests extends AndroidTestCase { - private static final String TAG = "SuggestTests"; +import android.content.res.AssetFileDescriptor; - private SuggestHelper sh; +import java.util.Locale; + +public class SuggestTests extends SuggestTestsBase { + private SuggestHelper mHelper; @Override - protected void setUp() { - int[] resId = new int[] { R.raw.test }; - sh = new SuggestHelper(TAG, getTestContext(), resId); + protected void setUp() throws Exception { + super.setUp(); + final AssetFileDescriptor dict = openTestRawResourceFd(R.raw.test); + mHelper = new SuggestHelper( + getContext(), mTestPackageFile, dict.getStartOffset(), dict.getLength(), + createKeyboardId(Locale.US)); + mHelper.setCorrectionMode(Suggest.CORRECTION_FULL_BIGRAM); } /************************** Tests ************************/ @@ -36,104 +41,105 @@ public class SuggestTests extends AndroidTestCase { * Tests for simple completions of one character. */ public void testCompletion1char() { - assertTrue(sh.isDefaultSuggestion("peopl", "people")); - assertTrue(sh.isDefaultSuggestion("abou", "about")); - assertTrue(sh.isDefaultSuggestion("thei", "their")); + suggested("people", mHelper.getFirstSuggestion("peopl")); + suggested("about", mHelper.getFirstSuggestion("abou")); + suggested("their", mHelper.getFirstSuggestion("thei")); } /** * Tests for simple completions of two characters. */ public void testCompletion2char() { - assertTrue(sh.isDefaultSuggestion("peop", "people")); - assertTrue(sh.isDefaultSuggestion("calli", "calling")); - assertTrue(sh.isDefaultSuggestion("busine", "business")); + suggested("people", mHelper.getFirstSuggestion("peop")); + suggested("calling", mHelper.getFirstSuggestion("calli")); + suggested("business", mHelper.getFirstSuggestion("busine")); } /** * Tests for proximity errors. */ public void testProximityPositive() { - assertTrue(sh.isDefaultSuggestion("peiple", "people")); - assertTrue(sh.isDefaultSuggestion("peoole", "people")); - assertTrue(sh.isDefaultSuggestion("pwpple", "people")); + suggested("typed peiple", "people", mHelper.getFirstSuggestion("peiple")); + suggested("typed peoole", "people", mHelper.getFirstSuggestion("peoole")); + suggested("typed pwpple", "people", mHelper.getFirstSuggestion("pwpple")); } /** - * Tests for proximity errors - negative, when the error key is not near. + * Tests for proximity errors - negative, when the error key is not close. */ public void testProximityNegative() { - assertFalse(sh.isDefaultSuggestion("arout", "about")); - assertFalse(sh.isDefaultSuggestion("ire", "are")); + notSuggested("about", mHelper.getFirstSuggestion("arout")); + notSuggested("are", mHelper.getFirstSuggestion("ire")); } /** * Tests for checking if apostrophes are added automatically. */ public void testApostropheInsertion() { - assertTrue(sh.isDefaultSuggestion("im", "I'm")); - assertTrue(sh.isDefaultSuggestion("dont", "don't")); + suggested("I'm", mHelper.getFirstSuggestion("im")); + suggested("don't", mHelper.getFirstSuggestion("dont")); } /** * Test to make sure apostrophed word is not suggested for an apostrophed word. */ public void testApostrophe() { - assertFalse(sh.isDefaultSuggestion("don't", "don't")); + notSuggested("don't", mHelper.getFirstSuggestion("don't")); } /** * Tests for suggestion of capitalized version of a word. */ public void testCapitalization() { - assertTrue(sh.isDefaultSuggestion("i'm", "I'm")); - assertTrue(sh.isDefaultSuggestion("sunday", "Sunday")); - assertTrue(sh.isDefaultSuggestion("sundat", "Sunday")); + suggested("I'm", mHelper.getFirstSuggestion("i'm")); + suggested("Sunday", mHelper.getFirstSuggestion("sunday")); + suggested("Sunday", mHelper.getFirstSuggestion("sundat")); } /** * Tests to see if more than one completion is provided for certain prefixes. */ public void testMultipleCompletions() { - assertTrue(sh.isASuggestion("com", "come")); - assertTrue(sh.isASuggestion("com", "company")); - assertTrue(sh.isASuggestion("th", "the")); - assertTrue(sh.isASuggestion("th", "that")); - assertTrue(sh.isASuggestion("th", "this")); - assertTrue(sh.isASuggestion("th", "they")); + isInSuggestions("com: come", mHelper.getSuggestIndex("com", "come")); + isInSuggestions("com: company", mHelper.getSuggestIndex("com", "company")); + isInSuggestions("th: the", mHelper.getSuggestIndex("th", "the")); + isInSuggestions("th: that", mHelper.getSuggestIndex("th", "that")); + isInSuggestions("th: this", mHelper.getSuggestIndex("th", "this")); + isInSuggestions("th: they", mHelper.getSuggestIndex("th", "they")); } /** * Does the suggestion engine recognize zero frequency words as valid words. */ public void testZeroFrequencyAccepted() { - assertTrue(sh.isValid("yikes")); - assertFalse(sh.isValid("yike")); + assertTrue("valid word yikes", mHelper.isValidWord("yikes")); + assertFalse("non valid word yike", mHelper.isValidWord("yike")); } /** * Tests to make sure that zero frequency words are not suggested as completions. */ public void testZeroFrequencySuggestionsNegative() { - assertFalse(sh.isASuggestion("yike", "yikes")); - assertFalse(sh.isASuggestion("what", "whatcha")); + assertTrue(mHelper.getSuggestIndex("yike", "yikes") < 0); + assertTrue(mHelper.getSuggestIndex("what", "whatcha") < 0); } /** - * Tests to ensure that words with large edit distances are not suggested, in some cases - * and not considered corrections, in some cases. + * Tests to ensure that words with large edit distances are not suggested, in some cases. + * Also such word is not considered auto correction, in some cases. */ public void testTooLargeEditDistance() { - assertFalse(sh.isASuggestion("sniyr", "about")); - assertFalse(sh.isDefaultCorrection("rjw", "the")); + assertTrue(mHelper.getSuggestIndex("sniyr", "about") < 0); + // TODO: The following test fails. + // notSuggested("the", mHelper.getAutoCorrection("rjw")); } /** - * Make sure sh.isValid is case-sensitive. + * Make sure mHelper.isValidWord is case-sensitive. */ public void testValidityCaseSensitivity() { - assertTrue(sh.isValid("Sunday")); - assertFalse(sh.isValid("sunday")); + assertTrue("valid word Sunday", mHelper.isValidWord("Sunday")); + assertFalse("non valid word sunday", mHelper.isValidWord("sunday")); } /** @@ -141,11 +147,11 @@ public class SuggestTests extends AndroidTestCase { */ public void testAccents() { // ni<LATIN SMALL LETTER N WITH TILDE>o - assertTrue(sh.isDefaultCorrection("nino", "ni\u00F1o")); + suggested("ni\u00F1o", mHelper.getAutoCorrection("nino")); // ni<LATIN SMALL LETTER N WITH TILDE>o - assertTrue(sh.isDefaultCorrection("nimo", "ni\u00F1o")); + suggested("ni\u00F1o", mHelper.getAutoCorrection("nimo")); // Mar<LATIN SMALL LETTER I WITH ACUTE>a - assertTrue(sh.isDefaultCorrection("maria", "Mar\u00EDa")); + suggested("Mar\u00EDa", mHelper.getAutoCorrection("maria")); } /** @@ -153,20 +159,29 @@ public class SuggestTests extends AndroidTestCase { * and don't show any when there aren't any */ public void testBigramsAtFirstChar() { - assertTrue(sh.isDefaultNextSuggestion("about", "p", "part")); - assertTrue(sh.isDefaultNextSuggestion("I'm", "a", "about")); - assertTrue(sh.isDefaultNextSuggestion("about", "b", "business")); - assertTrue(sh.isASuggestion("about", "b", "being")); - assertFalse(sh.isDefaultNextSuggestion("about", "p", "business")); + suggested("bigram: about p[art]", + "part", mHelper.getBigramFirstSuggestion("about", "p")); + suggested("bigram: I'm a[bout]", + "about", mHelper.getBigramFirstSuggestion("I'm", "a")); + suggested("bigram: about b[usiness]", + "business", mHelper.getBigramFirstSuggestion("about", "b")); + isInSuggestions("bigram: about b[eing]", + mHelper.searchBigramSuggestion("about", "b", "being")); + notSuggested("bigram: about p", + "business", mHelper.getBigramFirstSuggestion("about", "p")); } /** * Make sure bigrams score affects the original score */ public void testBigramsScoreEffect() { - assertTrue(sh.isDefaultCorrection("pa", "page")); - assertTrue(sh.isDefaultNextCorrection("about", "pa", "part")); - assertTrue(sh.isDefaultCorrection("sa", "said")); - assertTrue(sh.isDefaultNextCorrection("from", "sa", "same")); + suggested("single: page", + "page", mHelper.getAutoCorrection("pa")); + suggested("bigram: about pa[rt]", + "part", mHelper.getBigramAutoCorrection("about", "pa")); + // TODO: The following test fails. + // suggested("single: said", "said", mHelper.getAutoCorrection("sa")); + suggested("bigram: from sa[me]", + "same", mHelper.getBigramAutoCorrection("from", "sa")); } } diff --git a/tests/src/com/android/inputmethod/latin/SuggestTestsBase.java b/tests/src/com/android/inputmethod/latin/SuggestTestsBase.java new file mode 100644 index 000000000..8aadee42e --- /dev/null +++ b/tests/src/com/android/inputmethod/latin/SuggestTestsBase.java @@ -0,0 +1,87 @@ +/* + * 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; + +import android.content.res.AssetFileDescriptor; +import android.content.res.Configuration; +import android.test.AndroidTestCase; +import android.text.TextUtils; +import android.view.inputmethod.EditorInfo; + +import com.android.inputmethod.keyboard.KeyboardId; + +import java.io.File; +import java.io.InputStream; +import java.util.Locale; + +public class SuggestTestsBase extends AndroidTestCase { + protected File mTestPackageFile; + + @Override + protected void setUp() throws Exception { + super.setUp(); + mTestPackageFile = new File(getTestContext().getApplicationInfo().sourceDir); + } + + protected KeyboardId createKeyboardId(Locale locale) { + final int displayWidth = getContext().getResources().getDisplayMetrics().widthPixels; + return new KeyboardId(locale.toString() + " keyboard", + com.android.inputmethod.latin.R.xml.kbd_qwerty, locale, + Configuration.ORIENTATION_LANDSCAPE, displayWidth, KeyboardId.MODE_TEXT, + new EditorInfo(), false, KeyboardId.F2KEY_MODE_NONE, false, false, false, false); + } + + protected InputStream openTestRawResource(int resIdInTest) { + return getTestContext().getResources().openRawResource(resIdInTest); + } + + protected AssetFileDescriptor openTestRawResourceFd(int resIdInTest) { + return getTestContext().getResources().openRawResourceFd(resIdInTest); + } + + private static String format(String message, Object expected, Object actual) { + return message + " expected:<" + expected + "> but was:<" + actual + ">"; + } + + protected static void suggested(CharSequence expected, CharSequence actual) { + if (!TextUtils.equals(expected, actual)) + fail(format("assertEquals", expected, actual)); + } + + protected static void suggested(String message, CharSequence expected, CharSequence actual) { + if (!TextUtils.equals(expected, actual)) + fail(format(message, expected, actual)); + } + + protected static void notSuggested(CharSequence expected, CharSequence actual) { + if (TextUtils.equals(expected, actual)) + fail(format("assertNotEquals", expected, actual)); + } + + protected static void notSuggested(String message, CharSequence expected, CharSequence actual) { + if (TextUtils.equals(expected, actual)) + fail(format(message, expected, actual)); + } + + protected static void isInSuggestions(String message, int position) { + assertTrue(message, position >= 0); + } + + protected static void isNotInSuggestions(String message, int position) { + assertTrue(message, position < 0); + } +} diff --git a/tests/src/com/android/inputmethod/latin/UserBigramSuggestHelper.java b/tests/src/com/android/inputmethod/latin/UserBigramSuggestHelper.java new file mode 100644 index 000000000..46e5a2454 --- /dev/null +++ b/tests/src/com/android/inputmethod/latin/UserBigramSuggestHelper.java @@ -0,0 +1,100 @@ +/* + * 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; + +import com.android.inputmethod.keyboard.KeyboardId; + +import android.content.Context; +import android.text.TextUtils; + +import java.io.File; +import java.util.Locale; +import java.util.StringTokenizer; + +public class UserBigramSuggestHelper extends SuggestHelper { + private final Context mContext; + private UserBigramDictionary mUserBigram; + + public UserBigramSuggestHelper(Context context, File dictionaryPath, long startOffset, + long length, int userBigramMax, int userBigramDelete, KeyboardId keyboardId) { + super(context, dictionaryPath, startOffset, length, keyboardId); + mContext = context; + mUserBigram = new UserBigramDictionary(context, null, Locale.US.toString(), + Suggest.DIC_USER); + mUserBigram.setDatabaseMax(userBigramMax); + mUserBigram.setDatabaseDelete(userBigramDelete); + mSuggest.setCorrectionMode(Suggest.CORRECTION_FULL_BIGRAM); + mSuggest.setUserBigramDictionary(mUserBigram); + } + + public void changeUserBigramLocale(Locale locale) { + if (mUserBigram != null) { + flushUserBigrams(); + mUserBigram.close(); + mUserBigram = new UserBigramDictionary(mContext, null, locale.toString(), + Suggest.DIC_USER); + mSuggest.setUserBigramDictionary(mUserBigram); + } + } + + public int searchUserBigramSuggestion(CharSequence previous, char typed, + CharSequence expected) { + if (mUserBigram == null) return -1; + + flushUserBigrams(); + if (!TextUtils.isEmpty(previous) && !TextUtils.isEmpty(Character.toString(typed))) { + WordComposer firstChar = createWordComposer(Character.toString(typed)); + mSuggest.getSuggestions(null, firstChar, previous); + boolean reloading = mUserBigram.reloadDictionaryIfRequired(); + if (reloading) mUserBigram.waitForDictionaryLoading(); + mUserBigram.getBigrams(firstChar, previous, mSuggest); + } + + for (int i = 0; i < mSuggest.mBigramSuggestions.size(); i++) { + final CharSequence word = mSuggest.mBigramSuggestions.get(i); + if (TextUtils.equals(word, expected)) + return i; + } + + return -1; + } + + public void addToUserBigram(String sentence) { + StringTokenizer st = new StringTokenizer(sentence); + String previous = null; + while (st.hasMoreTokens()) { + String current = st.nextToken(); + if (previous != null) { + addToUserBigram(new String[] {previous, current}); + } + previous = current; + } + } + + public void addToUserBigram(String[] pair) { + if (mUserBigram != null && pair.length == 2) { + mUserBigram.addBigrams(pair[0], pair[1]); + } + } + + public void flushUserBigrams() { + if (mUserBigram != null) { + mUserBigram.flushPendingWrites(); + mUserBigram.waitUntilUpdateDBDone(); + } + } +} diff --git a/tests/src/com/android/inputmethod/latin/UserBigramSuggestTests.java b/tests/src/com/android/inputmethod/latin/UserBigramSuggestTests.java new file mode 100644 index 000000000..9bd85385e --- /dev/null +++ b/tests/src/com/android/inputmethod/latin/UserBigramSuggestTests.java @@ -0,0 +1,112 @@ +/* + * Copyright (C) 2010,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; +import com.android.inputmethod.latin.tests.R; + +import android.content.res.AssetFileDescriptor; + +import java.util.Locale; + +public class UserBigramSuggestTests extends SuggestTestsBase { + private static final int SUGGESTION_STARTS = 6; + private static final int MAX_DATA = 20; + private static final int DELETE_DATA = 10; + + private UserBigramSuggestHelper mHelper; + + @Override + protected void setUp() throws Exception { + super.setUp(); + final AssetFileDescriptor dict = openTestRawResourceFd(R.raw.test); + mHelper = new UserBigramSuggestHelper( + getContext(), mTestPackageFile, dict.getStartOffset(), dict.getLength(), + MAX_DATA, DELETE_DATA, createKeyboardId(Locale.US)); + } + + /************************** Tests ************************/ + + /** + * Test suggestion started at right time + */ + public void testUserBigram() { + for (int i = 0; i < SUGGESTION_STARTS; i++) mHelper.addToUserBigram(pair1); + for (int i = 0; i < (SUGGESTION_STARTS - 1); i++) mHelper.addToUserBigram(pair2); + + isInSuggestions("bigram", mHelper.searchUserBigramSuggestion("user", 'b', "bigram")); + isNotInSuggestions("platform", + mHelper.searchUserBigramSuggestion("android", 'p', "platform")); + } + + /** + * Test loading correct (locale) bigrams + */ + public void testOpenAndClose() { + for (int i = 0; i < SUGGESTION_STARTS; i++) mHelper.addToUserBigram(pair1); + isInSuggestions("bigram in default locale", + mHelper.searchUserBigramSuggestion("user", 'b', "bigram")); + + // change to fr_FR + mHelper.changeUserBigramLocale(Locale.FRANCE); + for (int i = 0; i < SUGGESTION_STARTS; i++) mHelper.addToUserBigram(pair3); + isInSuggestions("france in fr_FR", + mHelper.searchUserBigramSuggestion("locale", 'f', "france")); + isNotInSuggestions("bigram in fr_FR", + mHelper.searchUserBigramSuggestion("user", 'b', "bigram")); + + // change back to en_US + mHelper.changeUserBigramLocale(Locale.US); + isNotInSuggestions("france in en_US", + mHelper.searchUserBigramSuggestion("locale", 'f', "france")); + isInSuggestions("bigram in en_US", + mHelper.searchUserBigramSuggestion("user", 'b', "bigram")); + } + + /** + * Test data gets pruned when it is over maximum + */ + public void testPruningData() { + for (int i = 0; i < SUGGESTION_STARTS; i++) mHelper.addToUserBigram(sentence0); + mHelper.flushUserBigrams(); + isInSuggestions("world after several sentence 0", + mHelper.searchUserBigramSuggestion("Hello", 'w', "world")); + + mHelper.addToUserBigram(sentence1); + mHelper.addToUserBigram(sentence2); + isInSuggestions("world after sentence 1 and 2", + mHelper.searchUserBigramSuggestion("Hello", 'w', "world")); + + // pruning should happen + mHelper.addToUserBigram(sentence3); + mHelper.addToUserBigram(sentence4); + + // trying to reopen database to check pruning happened in database + mHelper.changeUserBigramLocale(Locale.US); + isNotInSuggestions("world after sentence 3 and 4", + mHelper.searchUserBigramSuggestion("Hello", 'w', "world")); + } + + private static final String[] pair1 = {"user", "bigram"}; + private static final String[] pair2 = {"android","platform"}; + private static final String[] pair3 = {"locale", "france"}; + private static final String sentence0 = "Hello world"; + private static final String sentence1 = "This is a test for user input based bigram"; + private static final String sentence2 = "It learns phrases that contain both dictionary and " + + "nondictionary words"; + private static final String sentence3 = "This should give better suggestions than the previous " + + "version"; + private static final String sentence4 = "Android stock keyboard is improving"; +} diff --git a/tests/src/com/android/inputmethod/latin/UserBigramTests.java b/tests/src/com/android/inputmethod/latin/UserBigramTests.java deleted file mode 100644 index cbf7bd8e1..000000000 --- a/tests/src/com/android/inputmethod/latin/UserBigramTests.java +++ /dev/null @@ -1,100 +0,0 @@ -/* - * Copyright (C) 2010 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.test.AndroidTestCase; -import com.android.inputmethod.latin.tests.R; -import java.util.Locale; - -public class UserBigramTests extends AndroidTestCase { - private static final String TAG = "UserBigramTests"; - - private static final int SUGGESTION_STARTS = 6; - private static final int MAX_DATA = 20; - private static final int DELETE_DATA = 10; - - private SuggestHelper sh; - - @Override - protected void setUp() { - int[] resId = new int[] { R.raw.test }; - sh = new SuggestHelper(TAG, getTestContext(), resId, MAX_DATA, DELETE_DATA); - } - - /************************** Tests ************************/ - - /** - * Test suggestion started at right time - */ - public void testUserBigram() { - for (int i = 0; i < SUGGESTION_STARTS; i++) sh.addToUserBigram(pair1); - for (int i = 0; i < (SUGGESTION_STARTS - 1); i++) sh.addToUserBigram(pair2); - - assertTrue(sh.isUserBigramSuggestion("user", 'b', "bigram")); - assertFalse(sh.isUserBigramSuggestion("android", 'p', "platform")); - } - - /** - * Test loading correct (locale) bigrams - */ - public void testOpenAndClose() { - for (int i = 0; i < SUGGESTION_STARTS; i++) sh.addToUserBigram(pair1); - assertTrue(sh.isUserBigramSuggestion("user", 'b', "bigram")); - - // change to fr_FR - sh.changeUserBigramLocale(getTestContext(), Locale.FRANCE); - for (int i = 0; i < SUGGESTION_STARTS; i++) sh.addToUserBigram(pair3); - assertTrue(sh.isUserBigramSuggestion("locale", 'f', "france")); - assertFalse(sh.isUserBigramSuggestion("user", 'b', "bigram")); - - // change back to en_US - sh.changeUserBigramLocale(getTestContext(), Locale.US); - assertFalse(sh.isUserBigramSuggestion("locale", 'f', "france")); - assertTrue(sh.isUserBigramSuggestion("user", 'b', "bigram")); - } - - /** - * Test data gets pruned when it is over maximum - */ - public void testPruningData() { - for (int i = 0; i < SUGGESTION_STARTS; i++) sh.addToUserBigram(sentence0); - sh.flushUserBigrams(); - assertTrue(sh.isUserBigramSuggestion("Hello", 'w', "world")); - - sh.addToUserBigram(sentence1); - sh.addToUserBigram(sentence2); - assertTrue(sh.isUserBigramSuggestion("Hello", 'w', "world")); - - // pruning should happen - sh.addToUserBigram(sentence3); - sh.addToUserBigram(sentence4); - - // trying to reopen database to check pruning happened in database - sh.changeUserBigramLocale(getTestContext(), Locale.US); - assertFalse(sh.isUserBigramSuggestion("Hello", 'w', "world")); - } - - final String[] pair1 = new String[] {"user", "bigram"}; - final String[] pair2 = new String[] {"android","platform"}; - final String[] pair3 = new String[] {"locale", "france"}; - final String sentence0 = "Hello world"; - final String sentence1 = "This is a test for user input based bigram"; - final String sentence2 = "It learns phrases that contain both dictionary and nondictionary " - + "words"; - final String sentence3 = "This should give better suggestions than the previous version"; - final String sentence4 = "Android stock keyboard is improving"; -} diff --git a/tests/src/com/android/inputmethod/latin/UtilsTests.java b/tests/src/com/android/inputmethod/latin/UtilsTests.java new file mode 100644 index 000000000..5c0b03a0a --- /dev/null +++ b/tests/src/com/android/inputmethod/latin/UtilsTests.java @@ -0,0 +1,67 @@ +/* + * Copyright (C) 2010,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; + +import android.test.AndroidTestCase; + +import com.android.inputmethod.latin.tests.R; + +public class UtilsTests extends AndroidTestCase { + + // The following is meant to be a reasonable default for + // the "word_separators" resource. + private static final String sSeparators = ".,:;!?-"; + + @Override + protected void setUp() throws Exception { + super.setUp(); + } + + /************************** Tests ************************/ + + /** + * Test for getting previous word (for bigram suggestions) + */ + public void testGetPreviousWord() { + // If one of the following cases breaks, the bigram suggestions won't work. + assertEquals(EditingUtils.getPreviousWord("abc def", sSeparators), "abc"); + assertNull(EditingUtils.getPreviousWord("abc", sSeparators)); + assertNull(EditingUtils.getPreviousWord("abc. def", sSeparators)); + + // The following tests reflect the current behavior of the function + // EditingUtils#getPreviousWord. + // TODO: However at this time, the code does never go + // into such a path, so it should be safe to change the behavior of + // this function if needed - especially since it does not seem very + // logical. These tests are just there to catch any unintentional + // changes in the behavior of the EditingUtils#getPreviousWord method. + assertEquals(EditingUtils.getPreviousWord("abc def ", sSeparators), "abc"); + assertEquals(EditingUtils.getPreviousWord("abc def.", sSeparators), "abc"); + assertEquals(EditingUtils.getPreviousWord("abc def .", sSeparators), "def"); + assertNull(EditingUtils.getPreviousWord("abc ", sSeparators)); + } + + /** + * Test for getting the word before the cursor (for bigram) + */ + public void testGetThisWord() { + assertEquals(EditingUtils.getThisWord("abc def", sSeparators), "def"); + assertEquals(EditingUtils.getThisWord("abc def ", sSeparators), "def"); + assertNull(EditingUtils.getThisWord("abc def.", sSeparators)); + assertNull(EditingUtils.getThisWord("abc def .", sSeparators)); + } +} |