diff options
Diffstat (limited to 'tests/src')
3 files changed, 1384 insertions, 212 deletions
diff --git a/tests/src/com/android/inputmethod/keyboard/MiniKeyboardBuilderTests.java b/tests/src/com/android/inputmethod/keyboard/MiniKeyboardBuilderTests.java index 7e3106d7f..600342a7c 100644 --- a/tests/src/com/android/inputmethod/keyboard/MiniKeyboardBuilderTests.java +++ b/tests/src/com/android/inputmethod/keyboard/MiniKeyboardBuilderTests.java @@ -25,6 +25,16 @@ public class MiniKeyboardBuilderTests extends AndroidTestCase { 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(); @@ -33,9 +43,8 @@ public class MiniKeyboardBuilderTests extends AndroidTestCase { public void testLayoutError() { MiniKeyboardLayoutParams params = null; try { - params = new MiniKeyboardLayoutParams( - 10, MAX_COLUMNS + 1, WIDTH, HEIGHT, - WIDTH * 2, WIDTH * MAX_COLUMNS); + 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. @@ -48,39 +57,198 @@ public class MiniKeyboardBuilderTests extends AndroidTestCase { // "[1]" is the default key. // [1] - public void testLayout1Key() { - MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams( - 1, MAX_COLUMNS, WIDTH, HEIGHT, - WIDTH * 5, WIDTH * 10); - assertEquals("1 key columns", 1, params.mNumColumns); - assertEquals("1 key rows", 1, params.mNumRows); - assertEquals("1 key left", 0, params.mLeftKeys); - assertEquals("1 key right", 1, params.mRightKeys); - assertEquals("1 key [1]", 0, params.getColumnPos(0)); - assertEquals("1 key centering", false, params.mTopRowNeedsCentering); - assertEquals("1 key default", 0, params.getDefaultKeyCoordX()); + 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 testLayout2Key() { - MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams( - 2, MAX_COLUMNS, WIDTH, HEIGHT, - WIDTH * 5, WIDTH * 10); - assertEquals("2 key columns", 2, params.mNumColumns); - assertEquals("2 key rows", 1, params.mNumRows); - assertEquals("2 key left", 0, params.mLeftKeys); - assertEquals("2 key right", 2, params.mRightKeys); - assertEquals("2 key [1]", 0, params.getColumnPos(0)); - assertEquals("2 key [2]", 1, params.getColumnPos(1)); - assertEquals("2 key centering", false, params.mTopRowNeedsCentering); - assertEquals("2 key default", 0, params.getDefaultKeyCoordX()); + 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 testLayout3Key() { - MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams( - 3, MAX_COLUMNS, WIDTH, HEIGHT, - WIDTH * 5, WIDTH * 10); + 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); @@ -88,15 +256,104 @@ public class MiniKeyboardBuilderTests extends AndroidTestCase { 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 centering", false, params.mTopRowNeedsCentering); - assertEquals("3 key default", WIDTH, params.getDefaultKeyCoordX()); + 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 testLayout4Key() { - MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams( - 4, MAX_COLUMNS, WIDTH, HEIGHT, - WIDTH * 5, WIDTH * 10); + 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); @@ -105,15 +362,110 @@ public class MiniKeyboardBuilderTests extends AndroidTestCase { 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 centering", false, params.mTopRowNeedsCentering); - assertEquals("4 key default", WIDTH, params.getDefaultKeyCoordX()); + 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 testLayout5Key() { - MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams( - 5, MAX_COLUMNS, WIDTH, HEIGHT, - WIDTH * 5, WIDTH * 10); + 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); @@ -123,190 +475,942 @@ public class MiniKeyboardBuilderTests extends AndroidTestCase { 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 centering", false, params.mTopRowNeedsCentering); + assertEquals("5 key adjust", 0, params.mTopRowAdjustment); assertEquals("5 key default", WIDTH * 2, params.getDefaultKeyCoordX()); } - // [6] - // [5] [3] [1] [2] [4] - public void testLayout6Key() { - MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams( - 6, MAX_COLUMNS, WIDTH, HEIGHT, - WIDTH * 5, WIDTH * 10); - assertEquals("6 key columns", 5, params.mNumColumns); + // |[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", 2, params.mLeftKeys); - assertEquals("6 key right", 3, params.mRightKeys); + 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]", 2, params.getColumnPos(3)); - assertEquals("6 key [5]", -2, params.getColumnPos(4)); - assertEquals("6 key [6]", 0, params.getColumnPos(5)); - assertEquals("6 key centering", false, params.mTopRowNeedsCentering); - assertEquals("6 key default", WIDTH * 2, params.getDefaultKeyCoordX()); + 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()); } - // [6] [7] - // [5] [3] [1] [2] [4] - public void testLayout7Key() { - MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams( - 7, MAX_COLUMNS, WIDTH, HEIGHT, - WIDTH * 5, WIDTH * 10); - assertEquals("7 key columns", 5, params.mNumColumns); + // |[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", 2, params.mLeftKeys); + 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]", -2, params.getColumnPos(4)); - assertEquals("7 key [6]", 0, params.getColumnPos(5)); - assertEquals("7 key [7]", 1, params.getColumnPos(6)); - assertEquals("7 key centering", true, params.mTopRowNeedsCentering); - assertEquals("7 key default", WIDTH * 2, params.getDefaultKeyCoordX()); + 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()); } - // [8] [6] [7] - // [5] [3] [1] [2] [4] - public void testLayout8Key() { - MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams( - 8, MAX_COLUMNS, WIDTH, HEIGHT, - WIDTH * 5, WIDTH * 10); - assertEquals("8 key columns", 5, params.mNumColumns); - assertEquals("8 key rows", 2, params.mNumRows); - assertEquals("8 key left", 2, params.mLeftKeys); - assertEquals("8 key right", 3, params.mRightKeys); - assertEquals("8 key [1]", 0, params.getColumnPos(0)); - assertEquals("8 key [2]", 1, params.getColumnPos(1)); - assertEquals("8 key [3]", -1, params.getColumnPos(2)); - assertEquals("8 key [4]", 2, params.getColumnPos(3)); - assertEquals("8 key [5]", -2, params.getColumnPos(4)); - assertEquals("8 key [6]", 0, params.getColumnPos(5)); - assertEquals("8 key [7]", 1, params.getColumnPos(6)); - assertEquals("8 key [8]", -1, params.getColumnPos(7)); - assertEquals("8 key centering", false, params.mTopRowNeedsCentering); - assertEquals("8 key default", WIDTH * 2, 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 testLayout9Key() { - MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams( - 9, MAX_COLUMNS, WIDTH, HEIGHT, - WIDTH * 5, WIDTH * 10); - assertEquals("9 key columns", 5, params.mNumColumns); - assertEquals("9 key rows", 2, params.mNumRows); - assertEquals("9 key left", 2, params.mLeftKeys); - assertEquals("9 key right", 3, params.mRightKeys); - assertEquals("9 key [1]", 0, params.getColumnPos(0)); - assertEquals("9 key [2]", 1, params.getColumnPos(1)); - assertEquals("9 key [3]", -1, params.getColumnPos(2)); - assertEquals("9 key [4]", 2, params.getColumnPos(3)); - assertEquals("9 key [5]", -2, params.getColumnPos(4)); - assertEquals("9 key [6]", 0, params.getColumnPos(5)); - assertEquals("9 key [7]", 1, params.getColumnPos(6)); - assertEquals("9 key [8]", -1, params.getColumnPos(7)); - assertEquals("9 key [9]", 2, params.getColumnPos(8)); - assertEquals("9 key centering", true, params.mTopRowNeedsCentering); - assertEquals("9 key default", WIDTH * 2, params.getDefaultKeyCoordX()); - } - - // Nine keys test. There is no key space for mini keyboard at left of the parent key. - // [6] [7] [8] [9] - // [1] [2] [3] [4] [5] - public void testLayout9KeyLeft() { - MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams( - 9, MAX_COLUMNS, WIDTH, HEIGHT, - 0, WIDTH * 10); - assertEquals("9 key left columns", 5, params.mNumColumns); - assertEquals("9 key left rows", 2, params.mNumRows); - assertEquals("9 key left left", 0, params.mLeftKeys); - assertEquals("9 key left right", 5, params.mRightKeys); - assertEquals("9 key left [1]", 0, params.getColumnPos(0)); - assertEquals("9 key left [2]", 1, params.getColumnPos(1)); - assertEquals("9 key left [3]", 2, params.getColumnPos(2)); - assertEquals("9 key left [4]", 3, params.getColumnPos(3)); - assertEquals("9 key left [5]", 4, params.getColumnPos(4)); - assertEquals("9 key left [6]", 0, params.getColumnPos(5)); - assertEquals("9 key left [7]", 1, params.getColumnPos(6)); - assertEquals("9 key left [8]", 2, params.getColumnPos(7)); - assertEquals("9 key left [9]", 3, params.getColumnPos(8)); - assertEquals("9 key left centering", true, params.mTopRowNeedsCentering); - assertEquals("9 key left default", 0, params.getDefaultKeyCoordX()); - } - - // Nine keys test. There is only one key space for mini keyboard at left of the parent key. - // [8] [6] [7] [9] - // [3] [1] [2] [4] [5] - public void testLayout9KeyNearLeft() { - MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams( - 9, MAX_COLUMNS, WIDTH, HEIGHT, - WIDTH, WIDTH * 10); - assertEquals("9 key near left columns", 5, params.mNumColumns); - assertEquals("9 key near left rows", 2, params.mNumRows); - assertEquals("9 key near left left", 1, params.mLeftKeys); - assertEquals("9 key near left right", 4, params.mRightKeys); - assertEquals("9 key near left [1]", 0, params.getColumnPos(0)); - assertEquals("9 key near left [2]", 1, params.getColumnPos(1)); - assertEquals("9 key near left [3]", -1, params.getColumnPos(2)); - assertEquals("9 key near left [4]", 2, params.getColumnPos(3)); - assertEquals("9 key near left [5]", 3, params.getColumnPos(4)); - assertEquals("9 key near left [6]", 0, params.getColumnPos(5)); - assertEquals("9 key near left [7]", 1, params.getColumnPos(6)); - assertEquals("9 key near left [8]", -1, params.getColumnPos(7)); - assertEquals("9 key near left [9]", 2, params.getColumnPos(8)); - assertEquals("9 key near left centering", true, params.mTopRowNeedsCentering); - assertEquals("9 key near left default", WIDTH, params.getDefaultKeyCoordX()); - } - - - // Nine keys test. There is no key space for mini keyboard at right of the parent key. - // [9] [8] [7] [6] - // [5] [4] [3] [2] [1] - public void testLayout9KeyRight() { - MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams( - 9, MAX_COLUMNS, WIDTH, HEIGHT, - WIDTH * 9, WIDTH * 10); - assertEquals("9 key right columns", 5, params.mNumColumns); - assertEquals("9 key right rows", 2, params.mNumRows); - assertEquals("9 key right left", 4, params.mLeftKeys); - assertEquals("9 key right right", 1, params.mRightKeys); - assertEquals("9 key right [1]", 0, params.getColumnPos(0)); - assertEquals("9 key right [2]", -1, params.getColumnPos(1)); - assertEquals("9 key right [3]", -2, params.getColumnPos(2)); - assertEquals("9 key right [4]", -3, params.getColumnPos(3)); - assertEquals("9 key right [5]", -4, params.getColumnPos(4)); - assertEquals("9 key right [6]", 0, params.getColumnPos(5)); - assertEquals("9 key right [7]", -1, params.getColumnPos(6)); - assertEquals("9 key right [8]", -2, params.getColumnPos(7)); - assertEquals("9 key right [9]", -3, params.getColumnPos(8)); - assertEquals("9 key right centering", true, params.mTopRowNeedsCentering); - assertEquals("9 key right default", WIDTH * 4, params.getDefaultKeyCoordX()); - } - - // Nine keys test. There is only one key space for mini keyboard at right of the parent key. - // [9] [8] [6] [7] - // [5] [4] [3] [1] [2] - public void testLayout9KeyNearRight() { - MiniKeyboardLayoutParams params = new MiniKeyboardLayoutParams( - 9, MAX_COLUMNS, WIDTH, HEIGHT, - WIDTH * 8, WIDTH * 10); - assertEquals("9 key near right columns", 5, params.mNumColumns); - assertEquals("9 key near right rows", 2, params.mNumRows); - assertEquals("9 key near right left", 3, params.mLeftKeys); - assertEquals("9 key near right right", 2, params.mRightKeys); - assertEquals("9 key near right [1]", 0, params.getColumnPos(0)); - assertEquals("9 key near right [2]", 1, params.getColumnPos(1)); - assertEquals("9 key near right [3]", -1, params.getColumnPos(2)); - assertEquals("9 key near right [4]", -2, params.getColumnPos(3)); - assertEquals("9 key near right [5]", -3, params.getColumnPos(4)); - assertEquals("9 key near right [6]", 0, params.getColumnPos(5)); - assertEquals("9 key near right [7]", 1, params.getColumnPos(6)); - assertEquals("9 key near right [8]", -1, params.getColumnPos(7)); - assertEquals("9 key near right [9]", -2, params.getColumnPos(8)); - assertEquals("9 key near right centering", true, params.mTopRowNeedsCentering); - assertEquals("9 key near right default", WIDTH * 3, params.getDefaultKeyCoordX()); + 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/latin/SuggestHelper.java b/tests/src/com/android/inputmethod/latin/SuggestHelper.java index 5930ea36e..8a11ff955 100644 --- a/tests/src/com/android/inputmethod/latin/SuggestHelper.java +++ b/tests/src/com/android/inputmethod/latin/SuggestHelper.java @@ -20,7 +20,6 @@ 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 com.android.inputmethod.keyboard.ProximityKeyDetector; import android.content.Context; import android.text.TextUtils; @@ -34,17 +33,19 @@ public class SuggestHelper { private final KeyDetector mKeyDetector; public SuggestHelper(Context context, int dictionaryId, KeyboardId keyboardId) { - mSuggest = new Suggest(context, dictionaryId); + // 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); - mKeyDetector = new ProximityKeyDetector(); + mKeyDetector = new KeyDetector(); init(); } protected SuggestHelper(Context context, File dictionaryPath, long startOffset, long length, KeyboardId keyboardId) { - mSuggest = new Suggest(dictionaryPath, startOffset, length); + mSuggest = new Suggest(context, dictionaryPath, startOffset, length, null); mKeyboard = new LatinKeyboard(context, keyboardId); - mKeyDetector = new ProximityKeyDetector(); + mKeyDetector = new KeyDetector(); init(); } @@ -53,7 +54,7 @@ public class SuggestHelper { mSuggest.setCorrectionMode(Suggest.CORRECTION_FULL); mKeyDetector.setKeyboard(mKeyboard, 0, 0); mKeyDetector.setProximityCorrectionEnabled(true); - mKeyDetector.setProximityThreshold(KeyDetector.getMostCommonKeyWidth(mKeyboard)); + mKeyDetector.setProximityThreshold(mKeyboard.getMostCommonKeyWidth()); } public void setCorrectionMode(int correctionMode) { 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)); + } +} |