1/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.inputmethod.keyboard;
18
19import android.test.AndroidTestCase;
20import android.test.suitebuilder.annotation.MediumTest;
21
22import com.android.inputmethod.keyboard.MoreKeysKeyboard.MoreKeysKeyboardParams;
23
24@MediumTest
25public class MoreKeysKeyboardBuilderMaxOrderTests extends AndroidTestCase {
26    private static final int WIDTH = 10;
27    private static final int HEIGHT = 10;
28
29    private static final int KEYBOARD_WIDTH = WIDTH * 10;
30    private static final int XPOS_L0 = WIDTH * 0 + WIDTH / 2;
31    private static final int XPOS_L1 = WIDTH * 1 + WIDTH / 2;
32    private static final int XPOS_L2 = WIDTH * 2 + WIDTH / 2;
33    private static final int XPOS_L3 = WIDTH * 3 + WIDTH / 2;
34    private static final int XPOS_M0 = WIDTH * 4 + WIDTH / 2;
35    private static final int XPOS_M1 = WIDTH * 5 + WIDTH / 2;
36    private static final int XPOS_R3 = WIDTH * 6 + WIDTH / 2;
37    private static final int XPOS_R2 = WIDTH * 7 + WIDTH / 2;
38    private static final int XPOS_R1 = WIDTH * 8 + WIDTH / 2;
39    private static final int XPOS_R0 = WIDTH * 9 + WIDTH / 2;
40
41    @Override
42    protected void setUp() throws Exception {
43        super.setUp();
44    }
45
46    private static MoreKeysKeyboardParams createParams(final int numKeys, final int maxColumns,
47            final int coordXInParent) {
48        final MoreKeysKeyboardParams params = new MoreKeysKeyboardParams();
49        params.setParameters(numKeys, maxColumns, WIDTH, HEIGHT, coordXInParent, KEYBOARD_WIDTH,
50                false /* isMoreKeysFixedColumn */, false /* isMoreKeysFixedOrder */,
51                0 /* dividerWidth */);
52        return params;
53    }
54
55    public void testLayoutError() {
56        MoreKeysKeyboardParams params = null;
57        try {
58            final int maxColumns = KEYBOARD_WIDTH / WIDTH;
59            params = createParams(maxColumns + 1, maxColumns + 1, HEIGHT);
60            fail("Should throw IllegalArgumentException");
61        } catch (IllegalArgumentException e) {
62            // Too small keyboard to hold more keys keyboard.
63        }
64        assertNull("Too small keyboard to hold more keys keyboard", params);
65    }
66
67    // More keys keyboard layout test.
68    // "[n]" represents n-th key position in more keys keyboard.
69    // "<1>" is the default key.
70
71    // <1>
72    public void testLayout1KeyMax5M0() {
73        MoreKeysKeyboardParams params = createParams(1, 5, XPOS_M0);
74        assertEquals("1 key max 5 M0 columns", 1, params.mNumColumns);
75        assertEquals("1 key max 5 M0 rows", 1, params.mNumRows);
76        assertEquals("1 key max 5 M0 left", 0, params.mLeftKeys);
77        assertEquals("1 key max 5 M0 right", 1, params.mRightKeys);
78        assertEquals("1 key max 5 M0 <1>", 0, params.getColumnPos(0));
79        assertEquals("1 key max 5 M0 adjust", 0, params.mTopRowAdjustment);
80        assertEquals("1 key max 5 M0 default", WIDTH * 0, params.getDefaultKeyCoordX());
81    }
82
83    // |<1>
84    public void testLayout1KeyMax5L0() {
85        MoreKeysKeyboardParams params = createParams(1, 5, XPOS_L0);
86        assertEquals("1 key max 5 L0 columns", 1, params.mNumColumns);
87        assertEquals("1 key max 5 L0 rows", 1, params.mNumRows);
88        assertEquals("1 key max 5 L0 left", 0, params.mLeftKeys);
89        assertEquals("1 key max 5 L0 right", 1, params.mRightKeys);
90        assertEquals("1 key max 5 L0 <1>", 0, params.getColumnPos(0));
91        assertEquals("1 key max 5 L0 adjust", 0, params.mTopRowAdjustment);
92        assertEquals("1 key max 5 L0 default", WIDTH * 0, params.getDefaultKeyCoordX());
93    }
94
95    // |___ <1>
96    public void testLayout1KeyMax5L1() {
97        MoreKeysKeyboardParams params = createParams(1, 5, XPOS_L1);
98        assertEquals("1 key max 5 L1 columns", 1, params.mNumColumns);
99        assertEquals("1 key max 5 L1 rows", 1, params.mNumRows);
100        assertEquals("1 key max 5 L1 left", 0, params.mLeftKeys);
101        assertEquals("1 key max 5 L1 right", 1, params.mRightKeys);
102        assertEquals("1 key max 5 L1 <1>", 0, params.getColumnPos(0));
103        assertEquals("1 key max 5 L1 adjust", 0, params.mTopRowAdjustment);
104        assertEquals("1 key max 5 L1 default", WIDTH * 0, params.getDefaultKeyCoordX());
105    }
106
107    // |___ ___ <1>
108    public void testLayout1KeyMax5L2() {
109        MoreKeysKeyboardParams params = createParams(1, 5, XPOS_L2);
110        assertEquals("1 key max 5 L2 columns", 1, params.mNumColumns);
111        assertEquals("1 key max 5 L2 rows", 1, params.mNumRows);
112        assertEquals("1 key max 5 L2 left", 0, params.mLeftKeys);
113        assertEquals("1 key max 5 L2 right", 1, params.mRightKeys);
114        assertEquals("1 key max 5 L2 <1>", 0, params.getColumnPos(0));
115        assertEquals("1 key max 5 L2 adjust", 0, params.mTopRowAdjustment);
116        assertEquals("1 key max 5 L2 default", WIDTH * 0, params.getDefaultKeyCoordX());
117    }
118
119    // <1>|
120    public void testLayout1KeyMax5R0() {
121        MoreKeysKeyboardParams params = createParams(1, 5, XPOS_R0);
122        assertEquals("1 key max 5 R0 columns", 1, params.mNumColumns);
123        assertEquals("1 key max 5 R0 rows", 1, params.mNumRows);
124        assertEquals("1 key max 5 R0 left", 0, params.mLeftKeys);
125        assertEquals("1 key max 5 R0 right", 1, params.mRightKeys);
126        assertEquals("1 key max 5 R0 <1>", 0, params.getColumnPos(0));
127        assertEquals("1 key max 5 R0 adjust", 0, params.mTopRowAdjustment);
128        assertEquals("1 key max 5 R0 default", WIDTH * 0, params.getDefaultKeyCoordX());
129    }
130
131    // <1> ___|
132    public void testLayout1KeyMax5R1() {
133        MoreKeysKeyboardParams params = createParams(1, 5, XPOS_R1);
134        assertEquals("1 key max 5 R1 columns", 1, params.mNumColumns);
135        assertEquals("1 key max 5 R1 rows", 1, params.mNumRows);
136        assertEquals("1 key max 5 R1 left", 0, params.mLeftKeys);
137        assertEquals("1 key max 5 R1 right", 1, params.mRightKeys);
138        assertEquals("1 key max 5 R1 <1>", 0, params.getColumnPos(0));
139        assertEquals("1 key max 5 R1 adjust", 0, params.mTopRowAdjustment);
140        assertEquals("1 key max 5 R1 default", WIDTH * 0, params.getDefaultKeyCoordX());
141    }
142
143    // <1> ___ ___|
144    public void testLayout1KeyMax5R2() {
145        MoreKeysKeyboardParams params = createParams(1, 5, XPOS_R2);
146        assertEquals("1 key max 5 R2 columns", 1, params.mNumColumns);
147        assertEquals("1 key max 5 R2 rows", 1, params.mNumRows);
148        assertEquals("1 key max 5 R2 left", 0, params.mLeftKeys);
149        assertEquals("1 key max 5 R2 right", 1, params.mRightKeys);
150        assertEquals("1 key max 5 R2 <1>", 0, params.getColumnPos(0));
151        assertEquals("1 key max 5 R2 adjust", 0, params.mTopRowAdjustment);
152        assertEquals("1 key max 5 R2 default", WIDTH * 0, params.getDefaultKeyCoordX());
153    }
154
155    // <1> [2]
156    public void testLayout2KeyMax5M0() {
157        MoreKeysKeyboardParams params = createParams(2, 5, XPOS_M0);
158        assertEquals("2 key max 5 M0 columns", 2, params.mNumColumns);
159        assertEquals("2 key max 5 M0 rows", 1, params.mNumRows);
160        assertEquals("2 key max 5 M0 left", 0, params.mLeftKeys);
161        assertEquals("2 key max 5 M0 right", 2, params.mRightKeys);
162        assertEquals("2 key max 5 M0 <1>", 0, params.getColumnPos(0));
163        assertEquals("2 key max 5 M0 [2]", 1, params.getColumnPos(1));
164        assertEquals("2 key max 5 M0 adjust", 0, params.mTopRowAdjustment);
165        assertEquals("2 key max 5 M0 default", WIDTH * 0, params.getDefaultKeyCoordX());
166    }
167
168    // |<1> [2]
169    public void testLayout2KeyMax5L0() {
170        MoreKeysKeyboardParams params = createParams(2, 5, XPOS_L0);
171        assertEquals("2 key max 5 L0 columns", 2, params.mNumColumns);
172        assertEquals("2 key max 5 L0 rows", 1, params.mNumRows);
173        assertEquals("2 key max 5 L0 left", 0, params.mLeftKeys);
174        assertEquals("2 key max 5 L0 right", 2, params.mRightKeys);
175        assertEquals("2 key max 5 L0 <1>", 0, params.getColumnPos(0));
176        assertEquals("2 key max 5 L0 [2]", 1, params.getColumnPos(1));
177        assertEquals("2 key max 5 L0 adjust", 0, params.mTopRowAdjustment);
178        assertEquals("2 key max 5 L0 default", WIDTH * 0, params.getDefaultKeyCoordX());
179    }
180
181    // |___ <1> [2]
182    public void testLayout2KeyMax5L1() {
183        MoreKeysKeyboardParams params = createParams(2, 5, XPOS_L1);
184        assertEquals("2 key max 5 L1 columns", 2, params.mNumColumns);
185        assertEquals("2 key max 5 L1 rows", 1, params.mNumRows);
186        assertEquals("2 key max 5 L1 left", 0, params.mLeftKeys);
187        assertEquals("2 key max 5 L1 right", 2, params.mRightKeys);
188        assertEquals("2 key max 5 L1 <1>", 0, params.getColumnPos(0));
189        assertEquals("2 key max 5 L1 [2]", 1, params.getColumnPos(1));
190        assertEquals("2 key max 5 L1 adjust", 0, params.mTopRowAdjustment);
191        assertEquals("2 key max 5 L1 default", WIDTH * 0, params.getDefaultKeyCoordX());
192    }
193
194    // |___ ___ <1> [2]
195    public void testLayout2KeyMax5L2() {
196        MoreKeysKeyboardParams params = createParams(2, 5, XPOS_L2);
197        assertEquals("2 key max 5 L2 columns", 2, params.mNumColumns);
198        assertEquals("2 key max 5 L2 rows", 1, params.mNumRows);
199        assertEquals("2 key max 5 L2 left", 0, params.mLeftKeys);
200        assertEquals("2 key max 5 L2 right", 2, params.mRightKeys);
201        assertEquals("2 key max 5 L2 <1>", 0, params.getColumnPos(0));
202        assertEquals("2 key max 5 L2 [2]", 1, params.getColumnPos(1));
203        assertEquals("2 key max 5 L2 adjust", 0, params.mTopRowAdjustment);
204        assertEquals("2 key max 5 L2 default", WIDTH * 0, params.getDefaultKeyCoordX());
205    }
206
207    // [2] <1>|
208    public void testLayout2KeyMax5R0() {
209        MoreKeysKeyboardParams params = createParams(2, 5, XPOS_R0);
210        assertEquals("2 key max 5 R0 columns", 2, params.mNumColumns);
211        assertEquals("2 key max 5 R0 rows", 1, params.mNumRows);
212        assertEquals("2 key max 5 R0 left", 1, params.mLeftKeys);
213        assertEquals("2 key max 5 R0 right", 1, params.mRightKeys);
214        assertEquals("2 key max 5 R0 <1>", 0, params.getColumnPos(0));
215        assertEquals("2 key max 5 R0 [2]", -1, params.getColumnPos(1));
216        assertEquals("2 key max 5 R0 adjust", 0, params.mTopRowAdjustment);
217        assertEquals("2 key max 5 R0 default", WIDTH * 1, params.getDefaultKeyCoordX());
218    }
219
220    // [2] <1> ___|
221    public void testLayout2KeyMax5R1() {
222        MoreKeysKeyboardParams params = createParams(2, 5, XPOS_R1);
223        assertEquals("2 key max 5 R1 columns", 2, params.mNumColumns);
224        assertEquals("2 key max 5 R1 rows", 1, params.mNumRows);
225        assertEquals("2 key max 5 R1 left", 1, params.mLeftKeys);
226        assertEquals("2 key max 5 R1 right", 1, params.mRightKeys);
227        assertEquals("2 key max 5 R1 <1>", 0, params.getColumnPos(0));
228        assertEquals("2 key max 5 R1 [2]", -1, params.getColumnPos(1));
229        assertEquals("2 key max 5 R1 adjust", 0, params.mTopRowAdjustment);
230        assertEquals("2 key max 5 R1 default", WIDTH * 1, params.getDefaultKeyCoordX());
231    }
232
233    // <1> [2] ___|
234    public void testLayout2KeyMax5R2() {
235        MoreKeysKeyboardParams params = createParams(2, 5, XPOS_R2);
236        assertEquals("2 key max 5 R2 columns", 2, params.mNumColumns);
237        assertEquals("2 key max 5 R2 rows", 1, params.mNumRows);
238        assertEquals("2 key max 5 R2 left", 0, params.mLeftKeys);
239        assertEquals("2 key max 5 R2 right", 2, params.mRightKeys);
240        assertEquals("2 key max 5 R2 <1>", 0, params.getColumnPos(0));
241        assertEquals("2 key max 5 R2 [2]", 1, params.getColumnPos(1));
242        assertEquals("2 key max 5 R2 adjust", 0, params.mTopRowAdjustment);
243        assertEquals("2 key max 5 R2 default", WIDTH * 0, params.getDefaultKeyCoordX());
244    }
245
246    // [3] <1> [2]
247    public void testLayout3KeyMax5M0() {
248        MoreKeysKeyboardParams params = createParams(3, 5, XPOS_M0);
249        assertEquals("3 key max 5 M0 columns", 3, params.mNumColumns);
250        assertEquals("3 key max 5 M0 rows", 1, params.mNumRows);
251        assertEquals("3 key max 5 M0 left", 1, params.mLeftKeys);
252        assertEquals("3 key max 5 M0 right", 2, params.mRightKeys);
253        assertEquals("3 key max 5 M0 <1>", 0, params.getColumnPos(0));
254        assertEquals("3 key max 5 M0 [2]", 1, params.getColumnPos(1));
255        assertEquals("3 key max 5 M0 [3]", -1, params.getColumnPos(2));
256        assertEquals("3 key max 5 M0 adjust", 0, params.mTopRowAdjustment);
257        assertEquals("3 key max 5 M0 default", WIDTH * 1, params.getDefaultKeyCoordX());
258    }
259
260    // |<1> [2] [3]
261    public void testLayout3KeyMax5L0() {
262        MoreKeysKeyboardParams params = createParams(3, 5, XPOS_L0);
263        assertEquals("3 key max 5 L0 columns", 3, params.mNumColumns);
264        assertEquals("3 key max 5 L0 rows", 1, params.mNumRows);
265        assertEquals("3 key max 5 L0 left", 0, params.mLeftKeys);
266        assertEquals("3 key max 5 L0 right", 3, params.mRightKeys);
267        assertEquals("3 key max 5 L0 <1>", 0, params.getColumnPos(0));
268        assertEquals("3 key max 5 L0 [2]", 1, params.getColumnPos(1));
269        assertEquals("3 key max 5 L0 [3]", 2, params.getColumnPos(2));
270        assertEquals("3 key max 5 L0 adjust", 0, params.mTopRowAdjustment);
271        assertEquals("3 key max 5 L0 default", WIDTH * 0, params.getDefaultKeyCoordX());
272    }
273
274    // |___ <1> [2] [3]
275    public void testLayout3KeyMax5L1() {
276        MoreKeysKeyboardParams params = createParams(3, 5, XPOS_L1);
277        assertEquals("3 key max 5 L1 columns", 3, params.mNumColumns);
278        assertEquals("3 key max 5 L1 rows", 1, params.mNumRows);
279        assertEquals("3 key max 5 L1 left", 0, params.mLeftKeys);
280        assertEquals("3 key max 5 L1 right", 3, params.mRightKeys);
281        assertEquals("3 key max 5 L1 <1>", 0, params.getColumnPos(0));
282        assertEquals("3 key max 5 L1 [2]", 1, params.getColumnPos(1));
283        assertEquals("3 key max 5 L1 [3]", 2, params.getColumnPos(2));
284        assertEquals("3 key max 5 L1 adjust", 0, params.mTopRowAdjustment);
285        assertEquals("3 key max 5 L1 default", WIDTH * 0, params.getDefaultKeyCoordX());
286    }
287
288    // |___ [3] <1> [2]
289    public void testLayout3KeyMax5L2() {
290        MoreKeysKeyboardParams params = createParams(3, 5, XPOS_L2);
291        assertEquals("3 key max 5 L2 columns", 3, params.mNumColumns);
292        assertEquals("3 key max 5 L2 rows", 1, params.mNumRows);
293        assertEquals("3 key max 5 L2 left", 1, params.mLeftKeys);
294        assertEquals("3 key max 5 L2 right", 2, params.mRightKeys);
295        assertEquals("3 key max 5 L2 <1>", 0, params.getColumnPos(0));
296        assertEquals("3 key max 5 L2 [2]", 1, params.getColumnPos(1));
297        assertEquals("3 key max 5 L2 [3]", -1, params.getColumnPos(2));
298        assertEquals("3 key max 5 L2 adjust", 0, params.mTopRowAdjustment);
299        assertEquals("3 key max 5 L2 default", WIDTH * 1, params.getDefaultKeyCoordX());
300    }
301
302    // [3] [2] <1>|
303    public void testLayout3KeyMax5R0() {
304        MoreKeysKeyboardParams params = createParams(3, 5, XPOS_R0);
305        assertEquals("3 key max 5 R0 columns", 3, params.mNumColumns);
306        assertEquals("3 key max 5 R0 rows", 1, params.mNumRows);
307        assertEquals("3 key max 5 R0 left", 2, params.mLeftKeys);
308        assertEquals("3 key max 5 R0 right", 1, params.mRightKeys);
309        assertEquals("3 key max 5 R0 <1>", 0, params.getColumnPos(0));
310        assertEquals("3 key max 5 R0 [2]", -1, params.getColumnPos(1));
311        assertEquals("3 key max 5 R0 [3]", -2, params.getColumnPos(2));
312        assertEquals("3 key max 5 R0 adjust", 0, params.mTopRowAdjustment);
313        assertEquals("3 key max 5 R0 default", WIDTH * 2, params.getDefaultKeyCoordX());
314    }
315
316    // [3] [2] <1> ___|
317    public void testLayout3KeyMax5R1() {
318        MoreKeysKeyboardParams params = createParams(3, 5, XPOS_R1);
319        assertEquals("3 key max 5 R1 columns", 3, params.mNumColumns);
320        assertEquals("3 key max 5 R1 rows", 1, params.mNumRows);
321        assertEquals("3 key max 5 R1 left", 2, params.mLeftKeys);
322        assertEquals("3 key max 5 R1 right", 1, params.mRightKeys);
323        assertEquals("3 key max 5 R1 <1>", 0, params.getColumnPos(0));
324        assertEquals("3 key max 5 R1 [2]", -1, params.getColumnPos(1));
325        assertEquals("3 key max 5 R1 [3]", -2, params.getColumnPos(2));
326        assertEquals("3 key max 5 R1 adjust", 0, params.mTopRowAdjustment);
327        assertEquals("3 key max 5 R1 default", WIDTH * 2, params.getDefaultKeyCoordX());
328    }
329
330    // [3] <1> [2] ___|
331    public void testLayout3KeyMax5R2() {
332        MoreKeysKeyboardParams params = createParams(3, 5, XPOS_R2);
333        assertEquals("3 key max 5 R2 columns", 3, params.mNumColumns);
334        assertEquals("3 key max 5 R2 rows", 1, params.mNumRows);
335        assertEquals("3 key max 5 R2 left", 1, params.mLeftKeys);
336        assertEquals("3 key max 5 R2 right", 2, params.mRightKeys);
337        assertEquals("3 key max 5 R2 <1>", 0, params.getColumnPos(0));
338        assertEquals("3 key max 5 R2 [2]", 1, params.getColumnPos(1));
339        assertEquals("3 key max 5 R2 [3]", -1, params.getColumnPos(2));
340        assertEquals("3 key max 5 R2 adjust", 0, params.mTopRowAdjustment);
341        assertEquals("3 key max 5 R2 default", WIDTH * 1, params.getDefaultKeyCoordX());
342    }
343
344    // [3]
345    // <1> [2]
346    public void testLayout3KeyMax2M0() {
347        MoreKeysKeyboardParams params = createParams(3, 2, XPOS_M0);
348        assertEquals("3 key max 2 M0 columns", 2, params.mNumColumns);
349        assertEquals("3 key max 2 M0 rows", 2, params.mNumRows);
350        assertEquals("3 key max 2 M0 left", 0, params.mLeftKeys);
351        assertEquals("3 key max 2 M0 right", 2, params.mRightKeys);
352        assertEquals("3 key max 2 M0 <1>", 0, params.getColumnPos(0));
353        assertEquals("3 key max 2 M0 [2]", 1, params.getColumnPos(1));
354        assertEquals("3 key max 2 M0 [3]", 0, params.getColumnPos(2));
355        assertEquals("3 key max 2 M0 adjust", 0, params.mTopRowAdjustment);
356        assertEquals("3 key max 2 M0 default", WIDTH * 0, params.getDefaultKeyCoordX());
357    }
358
359    // |[3]
360    // |<1> [2]
361    public void testLayout3KeyMax2L0() {
362        MoreKeysKeyboardParams params = createParams(3, 2, XPOS_L0);
363        assertEquals("3 key max 2 L0 columns", 2, params.mNumColumns);
364        assertEquals("3 key max 2 L0 rows", 2, params.mNumRows);
365        assertEquals("3 key max 2 L0 left", 0, params.mLeftKeys);
366        assertEquals("3 key max 2 L0 right", 2, params.mRightKeys);
367        assertEquals("3 key max 2 L0 <1>", 0, params.getColumnPos(0));
368        assertEquals("3 key max 2 L0 [2]", 1, params.getColumnPos(1));
369        assertEquals("3 key max 2 L0 [3]", 0, params.getColumnPos(2));
370        assertEquals("3 key max 2 L0 adjust", 0, params.mTopRowAdjustment);
371        assertEquals("3 key max 2 L0 default", WIDTH * 0, params.getDefaultKeyCoordX());
372    }
373
374    // |___ [3]
375    // |___ <1> [2]
376    public void testLayout3KeyMax2L1() {
377        MoreKeysKeyboardParams params = createParams(3, 2, XPOS_L1);
378        assertEquals("3 key max 2 L1 columns", 2, params.mNumColumns);
379        assertEquals("3 key max 2 L1 rows", 2, params.mNumRows);
380        assertEquals("3 key max 2 L1 left", 0, params.mLeftKeys);
381        assertEquals("3 key max 2 L1 right", 2, params.mRightKeys);
382        assertEquals("3 key max 2 L1 <1>", 0, params.getColumnPos(0));
383        assertEquals("3 key max 2 L1 [2]", 1, params.getColumnPos(1));
384        assertEquals("3 key max 2 L1 [3]", 0, params.getColumnPos(2));
385        assertEquals("3 key max 2 L1 adjust", 0, params.mTopRowAdjustment);
386        assertEquals("3 key max 2 L1 default", WIDTH * 0, params.getDefaultKeyCoordX());
387    }
388
389    // |        [3]
390    // |___ ___ <1> [2]
391    public void testLayout3KeyMax2L2() {
392        MoreKeysKeyboardParams params = createParams(3, 2, XPOS_L2);
393        assertEquals("3 key max 2 L2 columns", 2, params.mNumColumns);
394        assertEquals("3 key max 2 L2 rows", 2, params.mNumRows);
395        assertEquals("3 key max 2 L2 left", 0, params.mLeftKeys);
396        assertEquals("3 key max 2 L2 right", 2, params.mRightKeys);
397        assertEquals("3 key max 2 L2 <1>", 0, params.getColumnPos(0));
398        assertEquals("3 key max 2 L2 [2]", 1, params.getColumnPos(1));
399        assertEquals("3 key max 2 L2 [3]", 0, params.getColumnPos(2));
400        assertEquals("3 key max 2 L2 adjust", 0, params.mTopRowAdjustment);
401        assertEquals("3 key max 2 L2 default", WIDTH * 0, params.getDefaultKeyCoordX());
402    }
403
404    //     [3]|
405    // [2] <1>|
406    public void testLayout3KeyMax2R0() {
407        MoreKeysKeyboardParams params = createParams(3, 2, XPOS_R0);
408        assertEquals("3 key max 2 R0 columns", 2, params.mNumColumns);
409        assertEquals("3 key max 2 R0 rows", 2, params.mNumRows);
410        assertEquals("3 key max 2 R0 left", 1, params.mLeftKeys);
411        assertEquals("3 key max 2 R0 right", 1, params.mRightKeys);
412        assertEquals("3 key max 2 R0 <1>", 0, params.getColumnPos(0));
413        assertEquals("3 key max 2 R0 [2]", -1, params.getColumnPos(1));
414        assertEquals("3 key max 2 R0 [3]", 0, params.getColumnPos(2));
415        assertEquals("3 key max 2 R0 adjust", 0, params.mTopRowAdjustment);
416        assertEquals("3 key max 2 R0 default", WIDTH * 1, params.getDefaultKeyCoordX());
417    }
418
419    //     [3]    |
420    // [2] <1> ___|
421    public void testLayout3KeyMax2R1() {
422        MoreKeysKeyboardParams params = createParams(3, 2, XPOS_R1);
423        assertEquals("3 key max 2 R1 columns", 2, params.mNumColumns);
424        assertEquals("3 key max 2 R1 rows", 2, params.mNumRows);
425        assertEquals("3 key max 2 R1 left", 1, params.mLeftKeys);
426        assertEquals("3 key max 2 R1 right", 1, params.mRightKeys);
427        assertEquals("3 key max 2 R1 <1>", 0, params.getColumnPos(0));
428        assertEquals("3 key max 2 R1 [2]", -1, params.getColumnPos(1));
429        assertEquals("3 key max 2 R1 [3]", 0, params.getColumnPos(2));
430        assertEquals("3 key max 2 R1 adjust", 0, params.mTopRowAdjustment);
431        assertEquals("3 key max 2 R1 default", WIDTH * 1, params.getDefaultKeyCoordX());
432    }
433
434    // [3]        |
435    // <1> [2] ___|
436    public void testLayout3KeyMax2R2() {
437        MoreKeysKeyboardParams params = createParams(3, 2, XPOS_R2);
438        assertEquals("3 key max 2 R2 columns", 2, params.mNumColumns);
439        assertEquals("3 key max 2 R2 rows", 2, params.mNumRows);
440        assertEquals("3 key max 2 R2 left", 0, params.mLeftKeys);
441        assertEquals("3 key max 2 R2 right", 2, params.mRightKeys);
442        assertEquals("3 key max 2 R2 <1>", 0, params.getColumnPos(0));
443        assertEquals("3 key max 2 R2 [2]", 1, params.getColumnPos(1));
444        assertEquals("3 key max 2 R2 [3]", 0, params.getColumnPos(2));
445        assertEquals("3 key max 2 R2 adjust", 0, params.mTopRowAdjustment);
446        assertEquals("3 key max 2 R2 default", WIDTH * 0, params.getDefaultKeyCoordX());
447    }
448
449    // [3] [4]
450    // <1> [2]
451    public void testLayout4KeyMax3M0() {
452        MoreKeysKeyboardParams params = createParams(4, 3, XPOS_M0);
453        assertEquals("4 key max 3 M0 columns", 2, params.mNumColumns);
454        assertEquals("4 key max 3 M0 rows", 2, params.mNumRows);
455        assertEquals("4 key max 3 M0 left", 0, params.mLeftKeys);
456        assertEquals("4 key max 3 M0 right", 2, params.mRightKeys);
457        assertEquals("4 key max 3 M0 <1>", 0, params.getColumnPos(0));
458        assertEquals("4 key max 3 M0 [2]", 1, params.getColumnPos(1));
459        assertEquals("4 key max 3 M0 [3]", 0, params.getColumnPos(2));
460        assertEquals("4 key max 3 M0 [4]", 1, params.getColumnPos(3));
461        assertEquals("4 key max 3 M0 adjust", 0, params.mTopRowAdjustment);
462        assertEquals("4 key max 3 M0 default", WIDTH * 0, params.getDefaultKeyCoordX());
463    }
464
465    // |[3] [4]
466    // |<1> [2]
467    public void testLayout4KeyMax3L0() {
468        MoreKeysKeyboardParams params = createParams(4, 3, XPOS_L0);
469        assertEquals("4 key max 3 L0 columns", 2, params.mNumColumns);
470        assertEquals("4 key max 3 L0 rows", 2, params.mNumRows);
471        assertEquals("4 key max 3 L0 left", 0, params.mLeftKeys);
472        assertEquals("4 key max 3 L0 right", 2, params.mRightKeys);
473        assertEquals("4 key max 3 L0 <1>", 0, params.getColumnPos(0));
474        assertEquals("4 key max 3 L0 [2]", 1, params.getColumnPos(1));
475        assertEquals("4 key max 3 L0 [3]", 0, params.getColumnPos(2));
476        assertEquals("4 key max 3 L0 [4]", 1, params.getColumnPos(3));
477        assertEquals("4 key max 3 L0 adjust", 0, params.mTopRowAdjustment);
478        assertEquals("4 key max 3 L0 default", WIDTH * 0, params.getDefaultKeyCoordX());
479    }
480
481    // |___ [3] [4]
482    // |___ <1> [2]
483    public void testLayout4KeyMax3L1() {
484        MoreKeysKeyboardParams params = createParams(4, 3, XPOS_L1);
485        assertEquals("4 key max 3 L1 columns", 2, params.mNumColumns);
486        assertEquals("4 key max 3 L1 rows", 2, params.mNumRows);
487        assertEquals("4 key max 3 L1 left", 0, params.mLeftKeys);
488        assertEquals("4 key max 3 L1 right", 2, params.mRightKeys);
489        assertEquals("4 key max 3 L1 <1>", 0, params.getColumnPos(0));
490        assertEquals("4 key max 3 L1 [2]", 1, params.getColumnPos(1));
491        assertEquals("4 key max 3 L1 [3]", 0, params.getColumnPos(2));
492        assertEquals("4 key max 3 L1 [4]", 1, params.getColumnPos(3));
493        assertEquals("4 key max 3 L1 adjust", 0, params.mTopRowAdjustment);
494        assertEquals("4 key max 3 L1 default", WIDTH * 0, params.getDefaultKeyCoordX());
495    }
496
497    // |___ ___ [3] [4]
498    // |___ ___ <1> [2]
499    public void testLayout4KeyMax3L2() {
500        MoreKeysKeyboardParams params = createParams(4, 3, XPOS_L2);
501        assertEquals("4 key max 3 L2 columns", 2, params.mNumColumns);
502        assertEquals("4 key max 3 L2 rows", 2, params.mNumRows);
503        assertEquals("4 key max 3 L2 left", 0, params.mLeftKeys);
504        assertEquals("4 key max 3 L2 right", 2, params.mRightKeys);
505        assertEquals("4 key max 3 L2 <1>", 0, params.getColumnPos(0));
506        assertEquals("4 key max 3 L2 [2]", 1, params.getColumnPos(1));
507        assertEquals("4 key max 3 L2 [3]", 0, params.getColumnPos(2));
508        assertEquals("4 key max 3 L2 [4]", 1, params.getColumnPos(3));
509        assertEquals("4 key max 3 L2 adjust", 0, params.mTopRowAdjustment);
510        assertEquals("4 key max 3 L2 default", WIDTH * 0, params.getDefaultKeyCoordX());
511    }
512
513    // [4] [3]|
514    // [2] <1>|
515    public void testLayout4KeyMax3R0() {
516        MoreKeysKeyboardParams params = createParams(4, 3, XPOS_R0);
517        assertEquals("4 key max 3 R0 columns", 2, params.mNumColumns);
518        assertEquals("4 key max 3 R0 rows", 2, params.mNumRows);
519        assertEquals("4 key max 3 R0 left", 1, params.mLeftKeys);
520        assertEquals("4 key max 3 R0 right", 1, params.mRightKeys);
521        assertEquals("4 key max 3 R0 <1>", 0, params.getColumnPos(0));
522        assertEquals("4 key max 3 R0 [2]", -1, params.getColumnPos(1));
523        assertEquals("4 key max 3 R0 [3]", 0, params.getColumnPos(2));
524        assertEquals("4 key max 3 R0 [4]", -1, params.getColumnPos(3));
525        assertEquals("4 key max 3 R0 adjust", 0, params.mTopRowAdjustment);
526        assertEquals("4 key max 3 R0 default", WIDTH * 1, params.getDefaultKeyCoordX());
527    }
528
529    // [4] [3] ___|
530    // [2] <1> ___|
531    public void testLayout4KeyMax3R1() {
532        MoreKeysKeyboardParams params = createParams(4, 3, XPOS_R1);
533        assertEquals("4 key max 3 R1 columns", 2, params.mNumColumns);
534        assertEquals("4 key max 3 R1 rows", 2, params.mNumRows);
535        assertEquals("4 key max 3 R1 left", 1, params.mLeftKeys);
536        assertEquals("4 key max 3 R1 right", 1, params.mRightKeys);
537        assertEquals("4 key max 3 R1 <1>", 0, params.getColumnPos(0));
538        assertEquals("4 key max 3 R1 [2]", -1, params.getColumnPos(1));
539        assertEquals("4 key max 3 R1 [3]", 0, params.getColumnPos(2));
540        assertEquals("4 key max 3 R1 [4]", -1, params.getColumnPos(3));
541        assertEquals("4 key max 3 R1 adjust", 0, params.mTopRowAdjustment);
542        assertEquals("4 key max 3 R1 default", WIDTH * 1, params.getDefaultKeyCoordX());
543    }
544
545    // [3] [4] ___|
546    // <1> [2] ___|
547    public void testLayout4KeyMax3R2() {
548        MoreKeysKeyboardParams params = createParams(4, 3, XPOS_R2);
549        assertEquals("4 key max 3 R2 columns", 2, params.mNumColumns);
550        assertEquals("4 key max 3 R2 rows", 2, params.mNumRows);
551        assertEquals("4 key max 3 R2 left", 0, params.mLeftKeys);
552        assertEquals("4 key max 3 R2 right", 2, params.mRightKeys);
553        assertEquals("4 key max 3 R2 <1>", 0, params.getColumnPos(0));
554        assertEquals("4 key max 3 R2 [2]", 1, params.getColumnPos(1));
555        assertEquals("4 key max 3 R2 [3]", 0, params.getColumnPos(2));
556        assertEquals("4 key max 3 R2 [4]", 1, params.getColumnPos(3));
557        assertEquals("4 key max 3 R2 adjust", 0, params.mTopRowAdjustment);
558        assertEquals("4 key max 3 R2 default", WIDTH * 0, params.getDefaultKeyCoordX());
559    }
560
561    // [3] <1> [2] [4]
562    public void testLayout4KeyMax4M0() {
563        MoreKeysKeyboardParams params = createParams(4, 4, XPOS_M0);
564        assertEquals("4 key max 4 M0 columns", 4, params.mNumColumns);
565        assertEquals("4 key max 4 M0 rows", 1, params.mNumRows);
566        assertEquals("4 key max 4 M0 left", 1, params.mLeftKeys);
567        assertEquals("4 key max 4 M0 right", 3, params.mRightKeys);
568        assertEquals("4 key max 4 M0 <1>", 0, params.getColumnPos(0));
569        assertEquals("4 key max 4 M0 [2]", 1, params.getColumnPos(1));
570        assertEquals("4 key max 4 M0 [3]", -1, params.getColumnPos(2));
571        assertEquals("4 key max 4 M0 [4]", 2, params.getColumnPos(3));
572        assertEquals("4 key max 4 M0 adjust", 0, params.mTopRowAdjustment);
573        assertEquals("4 key max 4 M0 default", WIDTH * 1, params.getDefaultKeyCoordX());
574    }
575
576    // |<1> [2] [3] [4]
577    public void testLayout4KeyMax4L0() {
578        MoreKeysKeyboardParams params = createParams(4, 4, XPOS_L0);
579        assertEquals("4 key max 4 L0 columns", 4, params.mNumColumns);
580        assertEquals("4 key max 4 L0 rows", 1, params.mNumRows);
581        assertEquals("4 key max 4 L0 left", 0, params.mLeftKeys);
582        assertEquals("4 key max 4 L0 right", 4, params.mRightKeys);
583        assertEquals("4 key max 4 L0 <1>", 0, params.getColumnPos(0));
584        assertEquals("4 key max 4 L0 [2]", 1, params.getColumnPos(1));
585        assertEquals("4 key max 4 L0 [3]", 2, params.getColumnPos(2));
586        assertEquals("4 key max 4 L0 [4]", 3, params.getColumnPos(3));
587        assertEquals("4 key max 4 L0 adjust", 0, params.mTopRowAdjustment);
588        assertEquals("4 key max 4 L0 default", WIDTH * 0, params.getDefaultKeyCoordX());
589    }
590
591    // |___ <1> [2] [3] [4]
592    public void testLayout4KeyMax4L1() {
593        MoreKeysKeyboardParams params = createParams(4, 4, XPOS_L1);
594        assertEquals("4 key max 4 L1 columns", 4, params.mNumColumns);
595        assertEquals("4 key max 4 L1 rows", 1, params.mNumRows);
596        assertEquals("4 key max 4 L1 left", 0, params.mLeftKeys);
597        assertEquals("4 key max 4 L1 right", 4, params.mRightKeys);
598        assertEquals("4 key max 4 L1 <1>", 0, params.getColumnPos(0));
599        assertEquals("4 key max 4 L1 [2]", 1, params.getColumnPos(1));
600        assertEquals("4 key max 4 L1 [3]", 2, params.getColumnPos(2));
601        assertEquals("4 key max 4 L1 [4]", 3, params.getColumnPos(3));
602        assertEquals("4 key max 4 L1 adjust", 0, params.mTopRowAdjustment);
603        assertEquals("4 key max 4 L1 default", WIDTH * 0, params.getDefaultKeyCoordX());
604    }
605
606    // |___ [3] <1> [2] [4]
607    public void testLayout4KeyMax4L2() {
608        MoreKeysKeyboardParams params = createParams(4, 4, XPOS_L2);
609        assertEquals("4 key max 4 L2 columns", 4, params.mNumColumns);
610        assertEquals("4 key max 4 L2 rows", 1, params.mNumRows);
611        assertEquals("4 key max 4 L2 left", 1, params.mLeftKeys);
612        assertEquals("4 key max 4 L2 right", 3, params.mRightKeys);
613        assertEquals("4 key max 4 L2 <1>", 0, params.getColumnPos(0));
614        assertEquals("4 key max 4 L2 [2]", 1, params.getColumnPos(1));
615        assertEquals("4 key max 4 L2 [3]", -1, params.getColumnPos(2));
616        assertEquals("4 key max 4 L2 [4]", 2, params.getColumnPos(3));
617        assertEquals("4 key max 4 L2 adjust", 0, params.mTopRowAdjustment);
618        assertEquals("4 key max 4 L2 default", WIDTH * 1, params.getDefaultKeyCoordX());
619    }
620
621    // [4] [3] [2] <1>|
622    public void testLayout4KeyMax4R0() {
623        MoreKeysKeyboardParams params = createParams(4, 4, XPOS_R0);
624        assertEquals("4 key max 4 R0 columns", 4, params.mNumColumns);
625        assertEquals("4 key max 4 R0 rows", 1, params.mNumRows);
626        assertEquals("4 key max 4 R0 left", 3, params.mLeftKeys);
627        assertEquals("4 key max 4 R0 right", 1, params.mRightKeys);
628        assertEquals("4 key max 4 R0 <1>", 0, params.getColumnPos(0));
629        assertEquals("4 key max 4 R0 [2]", -1, params.getColumnPos(1));
630        assertEquals("4 key max 4 R0 [3]", -2, params.getColumnPos(2));
631        assertEquals("4 key max 4 R0 [4]", -3, params.getColumnPos(3));
632        assertEquals("4 key max 4 R0 adjust", 0, params.mTopRowAdjustment);
633        assertEquals("4 key max 4 R0 default", WIDTH * 3, params.getDefaultKeyCoordX());
634    }
635
636    // [4] [3] [2] <1> ___|
637    public void testLayout4KeyMax4R1() {
638        MoreKeysKeyboardParams params = createParams(4, 4, XPOS_R1);
639        assertEquals("4 key max 4 R1 columns", 4, params.mNumColumns);
640        assertEquals("4 key max 4 R1 rows", 1, params.mNumRows);
641        assertEquals("4 key max 4 R1 left", 3, params.mLeftKeys);
642        assertEquals("4 key max 4 R1 right", 1, params.mRightKeys);
643        assertEquals("4 key max 4 R1 <1>", 0, params.getColumnPos(0));
644        assertEquals("4 key max 4 R1 [2]", -1, params.getColumnPos(1));
645        assertEquals("4 key max 4 R1 [3]", -2, params.getColumnPos(2));
646        assertEquals("4 key max 4 R1 [4]", -3, params.getColumnPos(3));
647        assertEquals("4 key max 4 R1 adjust", 0, params.mTopRowAdjustment);
648        assertEquals("4 key max 4 R1 default", WIDTH * 3, params.getDefaultKeyCoordX());
649    }
650
651    // [4] [3] <1> [2] ___|
652    public void testLayout4KeyMax4R2() {
653        MoreKeysKeyboardParams params = createParams(4, 4, XPOS_R2);
654        assertEquals("4 key max 4 R2 columns", 4, params.mNumColumns);
655        assertEquals("4 key max 4 R2 rows", 1, params.mNumRows);
656        assertEquals("4 key max 4 R2 left", 2, params.mLeftKeys);
657        assertEquals("4 key max 4 R2 right", 2, params.mRightKeys);
658        assertEquals("4 key max 4 R2 <1>", 0, params.getColumnPos(0));
659        assertEquals("4 key max 4 R2 [2]", 1, params.getColumnPos(1));
660        assertEquals("4 key max 4 R2 [3]", -1, params.getColumnPos(2));
661        assertEquals("4 key max 4 R2 [4]", -2, params.getColumnPos(3));
662        assertEquals("4 key max 4 R2 adjust", 0, params.mTopRowAdjustment);
663        assertEquals("4 key max 4 R2 default", WIDTH * 2, params.getDefaultKeyCoordX());
664    }
665
666    // [3] <1> [2] [4]
667    public void testLayout4KeyMax5M0() {
668        MoreKeysKeyboardParams params = createParams(4, 5, XPOS_M0);
669        assertEquals("4 key max 5 M0 columns", 4, params.mNumColumns);
670        assertEquals("4 key max 5 M0 rows", 1, params.mNumRows);
671        assertEquals("4 key max 5 M0 left", 1, params.mLeftKeys);
672        assertEquals("4 key max 5 M0 right", 3, params.mRightKeys);
673        assertEquals("4 key max 5 M0 <1>", 0, params.getColumnPos(0));
674        assertEquals("4 key max 5 M0 [2]", 1, params.getColumnPos(1));
675        assertEquals("4 key max 5 M0 [3]", -1, params.getColumnPos(2));
676        assertEquals("4 key max 5 M0 [4]", 2, params.getColumnPos(3));
677        assertEquals("4 key max 5 M0 adjust", 0, params.mTopRowAdjustment);
678        assertEquals("4 key max 5 M0 default", WIDTH * 1, params.getDefaultKeyCoordX());
679    }
680
681    // |<1> [2] [3] [4]
682    public void testLayout4KeyMax5L0() {
683        MoreKeysKeyboardParams params = createParams(4, 5, XPOS_L0);
684        assertEquals("4 key max 5 L0 columns", 4, params.mNumColumns);
685        assertEquals("4 key max 5 L0 rows", 1, params.mNumRows);
686        assertEquals("4 key max 5 L0 left", 0, params.mLeftKeys);
687        assertEquals("4 key max 5 L0 right", 4, params.mRightKeys);
688        assertEquals("4 key max 5 L0 <1>", 0, params.getColumnPos(0));
689        assertEquals("4 key max 5 L0 [2]", 1, params.getColumnPos(1));
690        assertEquals("4 key max 5 L0 [3]", 2, params.getColumnPos(2));
691        assertEquals("4 key max 5 L0 [4]", 3, params.getColumnPos(3));
692        assertEquals("4 key max 5 L0 adjust", 0, params.mTopRowAdjustment);
693        assertEquals("4 key max 5 L0 default", WIDTH * 0, params.getDefaultKeyCoordX());
694    }
695
696    // |___ <1> [2] [3] [4]
697    public void testLayout4KeyMax5L1() {
698        MoreKeysKeyboardParams params = createParams(4, 5, XPOS_L1);
699        assertEquals("4 key max 5 L1 columns", 4, params.mNumColumns);
700        assertEquals("4 key max 5 L1 rows", 1, params.mNumRows);
701        assertEquals("4 key max 5 L1 left", 0, params.mLeftKeys);
702        assertEquals("4 key max 5 L1 right", 4, params.mRightKeys);
703        assertEquals("4 key max 5 L1 <1>", 0, params.getColumnPos(0));
704        assertEquals("4 key max 5 L1 [2]", 1, params.getColumnPos(1));
705        assertEquals("4 key max 5 L1 [3]", 2, params.getColumnPos(2));
706        assertEquals("4 key max 5 L1 [4]", 3, params.getColumnPos(3));
707        assertEquals("4 key max 5 L1 adjust", 0, params.mTopRowAdjustment);
708        assertEquals("4 key max 5 L1 default", WIDTH * 0, params.getDefaultKeyCoordX());
709    }
710
711    // |___ [3] <1> [2] [4]
712    public void testLayout4KeyMax5L2() {
713        MoreKeysKeyboardParams params = createParams(4, 5, XPOS_L2);
714        assertEquals("4 key max 5 L2 columns", 4, params.mNumColumns);
715        assertEquals("4 key max 5 L2 rows", 1, params.mNumRows);
716        assertEquals("4 key max 5 L2 left", 1, params.mLeftKeys);
717        assertEquals("4 key max 5 L2 right", 3, params.mRightKeys);
718        assertEquals("4 key max 5 L2 <1>", 0, params.getColumnPos(0));
719        assertEquals("4 key max 5 L2 [2]", 1, params.getColumnPos(1));
720        assertEquals("4 key max 5 L2 [3]", -1, params.getColumnPos(2));
721        assertEquals("4 key max 5 L2 [4]", 2, params.getColumnPos(3));
722        assertEquals("4 key max 5 L2 adjust", 0, params.mTopRowAdjustment);
723        assertEquals("4 key max 5 L2 default", WIDTH * 1, params.getDefaultKeyCoordX());
724    }
725
726    // [4] [3] [2] <1>|
727    public void testLayout4KeyMax5R0() {
728        MoreKeysKeyboardParams params = createParams(4, 5, XPOS_R0);
729        assertEquals("4 key max 5 R0 columns", 4, params.mNumColumns);
730        assertEquals("4 key max 5 R0 rows", 1, params.mNumRows);
731        assertEquals("4 key max 5 R0 left", 3, params.mLeftKeys);
732        assertEquals("4 key max 5 R0 right", 1, params.mRightKeys);
733        assertEquals("4 key max 5 R0 <1>", 0, params.getColumnPos(0));
734        assertEquals("4 key max 5 R0 [2]", -1, params.getColumnPos(1));
735        assertEquals("4 key max 5 R0 [3]", -2, params.getColumnPos(2));
736        assertEquals("4 key max 5 R0 [4]", -3, params.getColumnPos(3));
737        assertEquals("4 key max 5 R0 adjust", 0, params.mTopRowAdjustment);
738        assertEquals("4 key max 5 R0 default", WIDTH * 3, params.getDefaultKeyCoordX());
739    }
740
741    // [4] [3] [2] <1> ___|
742    public void testLayout4KeyMax5R1() {
743        MoreKeysKeyboardParams params = createParams(4, 5, XPOS_R1);
744        assertEquals("4 key max 5 R1 columns", 4, params.mNumColumns);
745        assertEquals("4 key max 5 R1 rows", 1, params.mNumRows);
746        assertEquals("4 key max 5 R1 left", 3, params.mLeftKeys);
747        assertEquals("4 key max 5 R1 right", 1, params.mRightKeys);
748        assertEquals("4 key max 5 R1 <1>", 0, params.getColumnPos(0));
749        assertEquals("4 key max 5 R1 [2]", -1, params.getColumnPos(1));
750        assertEquals("4 key max 5 R1 [3]", -2, params.getColumnPos(2));
751        assertEquals("4 key max 5 R1 [4]", -3, params.getColumnPos(3));
752        assertEquals("4 key max 5 R1 adjust", 0, params.mTopRowAdjustment);
753        assertEquals("4 key max 5 R1 default", WIDTH * 3, params.getDefaultKeyCoordX());
754    }
755
756    // [4] [3] <1> [2] ___|
757    public void testLayout4KeyMax5R2() {
758        MoreKeysKeyboardParams params = createParams(4, 5, XPOS_R2);
759        assertEquals("4 key max 5 R2 columns", 4, params.mNumColumns);
760        assertEquals("4 key max 5 R2 rows", 1, params.mNumRows);
761        assertEquals("4 key max 5 R2 left", 2, params.mLeftKeys);
762        assertEquals("4 key max 5 R2 right", 2, params.mRightKeys);
763        assertEquals("4 key max 5 R2 <1>", 0, params.getColumnPos(0));
764        assertEquals("4 key max 5 R2 [2]", 1, params.getColumnPos(1));
765        assertEquals("4 key max 5 R2 [3]", -1, params.getColumnPos(2));
766        assertEquals("4 key max 5 R2 [4]", -2, params.getColumnPos(3));
767        assertEquals("4 key max 5 R2 adjust", 0, params.mTopRowAdjustment);
768        assertEquals("4 key max 5 R2 default", WIDTH * 2, params.getDefaultKeyCoordX());
769    }
770
771    //   [4] [5]
772    // [3] <1> [2]
773    public void testLayout5KeyMax3M0() {
774        MoreKeysKeyboardParams params = createParams(5, 3, XPOS_M0);
775        assertEquals("5 key max 3 M0 columns", 3, params.mNumColumns);
776        assertEquals("5 key max 3 M0 rows", 2, params.mNumRows);
777        assertEquals("5 key max 3 M0 left", 1, params.mLeftKeys);
778        assertEquals("5 key max 3 M0 right", 2, params.mRightKeys);
779        assertEquals("5 key max 3 M0 <1>", 0, params.getColumnPos(0));
780        assertEquals("5 key max 3 M0 [2]", 1, params.getColumnPos(1));
781        assertEquals("5 key max 3 M0 [3]", -1, params.getColumnPos(2));
782        assertEquals("5 key max 3 M0 [4]", 0, params.getColumnPos(3));
783        assertEquals("5 key max 3 M0 [5]", 1, params.getColumnPos(4));
784        assertEquals("5 key max 3 M0 adjust", -1, params.mTopRowAdjustment);
785        assertEquals("5 key max 3 M0 default", WIDTH * 1, params.getDefaultKeyCoordX());
786    }
787
788    // |[4] [5]
789    // |<1> [2] [3]
790    public void testLayout5KeyMax3L0() {
791        MoreKeysKeyboardParams params = createParams(5, 3, XPOS_L0);
792        assertEquals("5 key max 3 L0 columns", 3, params.mNumColumns);
793        assertEquals("5 key max 3 L0 rows", 2, params.mNumRows);
794        assertEquals("5 key max 3 L0 left", 0, params.mLeftKeys);
795        assertEquals("5 key max 3 L0 right", 3, params.mRightKeys);
796        assertEquals("5 key max 3 L0 <1>", 0, params.getColumnPos(0));
797        assertEquals("5 key max 3 L0 [2]", 1, params.getColumnPos(1));
798        assertEquals("5 key max 3 L0 [3]", 2, params.getColumnPos(2));
799        assertEquals("5 key max 3 L0 [4]", 0, params.getColumnPos(3));
800        assertEquals("5 key max 3 L0 [5]", 1, params.getColumnPos(4));
801        assertEquals("5 key max 3 L0 adjust", 0, params.mTopRowAdjustment);
802        assertEquals("5 key max 3 L0 default", WIDTH * 0, params.getDefaultKeyCoordX());
803    }
804
805    // |___ [4] [5]
806    // |___ <1> [2] [3]
807    public void testLayout5KeyMax3L1() {
808        MoreKeysKeyboardParams params = createParams(5, 3, XPOS_L1);
809        assertEquals("5 key max 3 L1 columns", 3, params.mNumColumns);
810        assertEquals("5 key max 3 L1 rows", 2, params.mNumRows);
811        assertEquals("5 key max 3 L1 left", 0, params.mLeftKeys);
812        assertEquals("5 key max 3 L1 right", 3, params.mRightKeys);
813        assertEquals("5 key max 3 L1 <1>", 0, params.getColumnPos(0));
814        assertEquals("5 key max 3 L1 [2]", 1, params.getColumnPos(1));
815        assertEquals("5 key max 3 L1 [3]", 2, params.getColumnPos(2));
816        assertEquals("5 key max 3 L1 [4]", 0, params.getColumnPos(3));
817        assertEquals("5 key max 3 L1 [5]", 1, params.getColumnPos(4));
818        assertEquals("5 key max 3 L1 adjust", 0, params.mTopRowAdjustment);
819        assertEquals("5 key max 3 L1 default", WIDTH * 0, params.getDefaultKeyCoordX());
820    }
821
822    // |___   [4] [5]
823    // |___ [3] <1> [2]
824    public void testLayout5KeyMax3L2() {
825        MoreKeysKeyboardParams params = createParams(5, 3, XPOS_L2);
826        assertEquals("5 key max 3 L2 columns", 3, params.mNumColumns);
827        assertEquals("5 key max 3 L2 rows", 2, params.mNumRows);
828        assertEquals("5 key max 3 L2 left", 1, params.mLeftKeys);
829        assertEquals("5 key max 3 L2 right", 2, params.mRightKeys);
830        assertEquals("5 key max 3 L2 <1>", 0, params.getColumnPos(0));
831        assertEquals("5 key max 3 L2 [2]", 1, params.getColumnPos(1));
832        assertEquals("5 key max 3 L2 [3]", -1, params.getColumnPos(2));
833        assertEquals("5 key max 3 L2 [4]", 0, params.getColumnPos(3));
834        assertEquals("5 key max 3 L2 [5]", 1, params.getColumnPos(4));
835        assertEquals("5 key max 3 L2 adjust", -1, params.mTopRowAdjustment);
836        assertEquals("5 key max 3 L2 default", WIDTH * 1, params.getDefaultKeyCoordX());
837    }
838
839    //     [5] [4]|
840    // [3] [2] <1>|
841    public void testLayout5KeyMax3R0() {
842        MoreKeysKeyboardParams params = createParams(5, 3, XPOS_R0);
843        assertEquals("5 key max 3 R0 columns", 3, params.mNumColumns);
844        assertEquals("5 key max 3 R0 rows", 2, params.mNumRows);
845        assertEquals("5 key max 3 R0 left", 2, params.mLeftKeys);
846        assertEquals("5 key max 3 R0 right", 1, params.mRightKeys);
847        assertEquals("5 key max 3 R0 <1>", 0, params.getColumnPos(0));
848        assertEquals("5 key max 3 R0 [2]", -1, params.getColumnPos(1));
849        assertEquals("5 key max 3 R0 [3]", -2, params.getColumnPos(2));
850        assertEquals("5 key max 3 R0 [4]", 0, params.getColumnPos(3));
851        assertEquals("5 key max 3 R0 [5]", -1, params.getColumnPos(4));
852        assertEquals("5 key max 3 R0 adjust", 0, params.mTopRowAdjustment);
853        assertEquals("5 key max 3 R0 default", WIDTH * 2, params.getDefaultKeyCoordX());
854    }
855
856    //     [5] [4] ___|
857    // [3] [2] <1> ___|
858    public void testLayout5KeyMax3R1() {
859        MoreKeysKeyboardParams params = createParams(5, 3, XPOS_R1);
860        assertEquals("5 key max 3 R1 columns", 3, params.mNumColumns);
861        assertEquals("5 key max 3 R1 rows", 2, params.mNumRows);
862        assertEquals("5 key max 3 R1 left", 2, params.mLeftKeys);
863        assertEquals("5 key max 3 R1 right", 1, params.mRightKeys);
864        assertEquals("5 key max 3 R1 <1>", 0, params.getColumnPos(0));
865        assertEquals("5 key max 3 R1 [2]", -1, params.getColumnPos(1));
866        assertEquals("5 key max 3 R1 [3]", -2, params.getColumnPos(2));
867        assertEquals("5 key max 3 R1 [4]", 0, params.getColumnPos(3));
868        assertEquals("5 key max 3 R1 [5]", -1, params.getColumnPos(4));
869        assertEquals("5 key max 3 R1 adjust", 0, params.mTopRowAdjustment);
870        assertEquals("5 key max 3 R1 default", WIDTH * 2, params.getDefaultKeyCoordX());
871    }
872
873    //   [4] [5]   ___|
874    // [3] <1> [2] ___|
875    public void testLayout5KeyMax3R2() {
876        MoreKeysKeyboardParams params = createParams(5, 3, XPOS_R2);
877        assertEquals("5 key max 3 R2 columns", 3, params.mNumColumns);
878        assertEquals("5 key max 3 R2 rows", 2, params.mNumRows);
879        assertEquals("5 key max 3 R2 left", 1, params.mLeftKeys);
880        assertEquals("5 key max 3 R2 right", 2, params.mRightKeys);
881        assertEquals("5 key max 3 R2 <1>", 0, params.getColumnPos(0));
882        assertEquals("5 key max 3 R2 [2]", 1, params.getColumnPos(1));
883        assertEquals("5 key max 3 R2 [3]", -1, params.getColumnPos(2));
884        assertEquals("5 key max 3 R2 [4]", 0, params.getColumnPos(3));
885        assertEquals("5 key max 3 R2 [5]", 1, params.getColumnPos(4));
886        assertEquals("5 key max 3 R2 adjust", -1, params.mTopRowAdjustment);
887        assertEquals("5 key max 3 R2 default", WIDTH * 1, params.getDefaultKeyCoordX());
888    }
889
890    //   [4] [5]
891    // [3] <1> [2]
892    public void testLayout5KeyMax4M0() {
893        MoreKeysKeyboardParams params = createParams(5, 4, XPOS_M0);
894        assertEquals("5 key max 4 M0 columns", 3, params.mNumColumns);
895        assertEquals("5 key max 4 M0 rows", 2, params.mNumRows);
896        assertEquals("5 key max 4 M0 left", 1, params.mLeftKeys);
897        assertEquals("5 key max 4 M0 right", 2, params.mRightKeys);
898        assertEquals("5 key max 4 M0 <1>", 0, params.getColumnPos(0));
899        assertEquals("5 key max 4 M0 [2]", 1, params.getColumnPos(1));
900        assertEquals("5 key max 4 M0 [3]", -1, params.getColumnPos(2));
901        assertEquals("5 key max 4 M0 [4]", 0, params.getColumnPos(3));
902        assertEquals("5 key max 4 M0 [5]", 1, params.getColumnPos(4));
903        assertEquals("5 key max 4 M0 adjust", -1, params.mTopRowAdjustment);
904        assertEquals("5 key max 4 M0 default", WIDTH * 1, params.getDefaultKeyCoordX());
905    }
906
907    // |[4] [5]
908    // |<1> [2] [3]
909    public void testLayout5KeyMax4L0() {
910        MoreKeysKeyboardParams params = createParams(5, 4, XPOS_L0);
911        assertEquals("5 key max 4 L0 columns", 3, params.mNumColumns);
912        assertEquals("5 key max 4 L0 rows", 2, params.mNumRows);
913        assertEquals("5 key max 4 L0 left", 0, params.mLeftKeys);
914        assertEquals("5 key max 4 L0 right", 3, params.mRightKeys);
915        assertEquals("5 key max 4 L0 <1>", 0, params.getColumnPos(0));
916        assertEquals("5 key max 4 L0 [2]", 1, params.getColumnPos(1));
917        assertEquals("5 key max 4 L0 [3]", 2, params.getColumnPos(2));
918        assertEquals("5 key max 4 L0 [4]", 0, params.getColumnPos(3));
919        assertEquals("5 key max 4 L0 [5]", 1, params.getColumnPos(4));
920        assertEquals("5 key max 4 L0 adjust", 0, params.mTopRowAdjustment);
921        assertEquals("5 key max 4 L0 default", WIDTH * 0, params.getDefaultKeyCoordX());
922    }
923
924    // |___ [4] [5]
925    // |___ <1> [2] [3]
926    public void testLayout5KeyMax4L1() {
927        MoreKeysKeyboardParams params = createParams(5, 4, XPOS_L1);
928        assertEquals("5 key max 4 L1 columns", 3, params.mNumColumns);
929        assertEquals("5 key max 4 L1 rows", 2, params.mNumRows);
930        assertEquals("5 key max 4 L1 left", 0, params.mLeftKeys);
931        assertEquals("5 key max 4 L1 right", 3, params.mRightKeys);
932        assertEquals("5 key max 4 L1 <1>", 0, params.getColumnPos(0));
933        assertEquals("5 key max 4 L1 [2]", 1, params.getColumnPos(1));
934        assertEquals("5 key max 4 L1 [3]", 2, params.getColumnPos(2));
935        assertEquals("5 key max 4 L1 [4]", 0, params.getColumnPos(3));
936        assertEquals("5 key max 4 L1 [5]", 1, params.getColumnPos(4));
937        assertEquals("5 key max 4 L1 adjust", 0, params.mTopRowAdjustment);
938        assertEquals("5 key max 4 L1 default", WIDTH * 0, params.getDefaultKeyCoordX());
939    }
940
941    // |___   [4] [5]
942    // |___ [3] <1> [2]
943    public void testLayout5KeyMax4L2() {
944        MoreKeysKeyboardParams params = createParams(5, 4, XPOS_L2);
945        assertEquals("5 key max 4 L2 columns", 3, params.mNumColumns);
946        assertEquals("5 key max 4 L2 rows", 2, params.mNumRows);
947        assertEquals("5 key max 4 L2 left", 1, params.mLeftKeys);
948        assertEquals("5 key max 4 L2 right", 2, params.mRightKeys);
949        assertEquals("5 key max 4 L2 <1>", 0, params.getColumnPos(0));
950        assertEquals("5 key max 4 L2 [2]", 1, params.getColumnPos(1));
951        assertEquals("5 key max 4 L2 [3]", -1, params.getColumnPos(2));
952        assertEquals("5 key max 4 L2 [4]", 0, params.getColumnPos(3));
953        assertEquals("5 key max 4 L2 [5]", 1, params.getColumnPos(4));
954        assertEquals("5 key max 4 L2 adjust", -1, params.mTopRowAdjustment);
955        assertEquals("5 key max 4 L2 default", WIDTH * 1, params.getDefaultKeyCoordX());
956    }
957
958    //     [5] [4]|
959    // [3] [2] <1>|
960    public void testLayout5KeyMax4R0() {
961        MoreKeysKeyboardParams params = createParams(5, 4, XPOS_R0);
962        assertEquals("5 key max 4 R0 columns", 3, params.mNumColumns);
963        assertEquals("5 key max 4 R0 rows", 2, params.mNumRows);
964        assertEquals("5 key max 4 R0 left", 2, params.mLeftKeys);
965        assertEquals("5 key max 4 R0 right", 1, params.mRightKeys);
966        assertEquals("5 key max 4 R0 <1>", 0, params.getColumnPos(0));
967        assertEquals("5 key max 4 R0 [2]", -1, params.getColumnPos(1));
968        assertEquals("5 key max 4 R0 [3]", -2, params.getColumnPos(2));
969        assertEquals("5 key max 4 R0 [4]", 0, params.getColumnPos(3));
970        assertEquals("5 key max 4 R0 [5]", -1, params.getColumnPos(4));
971        assertEquals("5 key max 4 R0 adjust", 0, params.mTopRowAdjustment);
972        assertEquals("5 key max 4 R0 default", WIDTH * 2, params.getDefaultKeyCoordX());
973    }
974
975    //     [5] [4] ___|
976    // [3] [2] <1> ___|
977    public void testLayout5KeyMax4R1() {
978        MoreKeysKeyboardParams params = createParams(5, 4, XPOS_R1);
979        assertEquals("5 key max 4 R1 columns", 3, params.mNumColumns);
980        assertEquals("5 key max 4 R1 rows", 2, params.mNumRows);
981        assertEquals("5 key max 4 R1 left", 2, params.mLeftKeys);
982        assertEquals("5 key max 4 R1 right", 1, params.mRightKeys);
983        assertEquals("5 key max 4 R1 <1>", 0, params.getColumnPos(0));
984        assertEquals("5 key max 4 R1 [2]", -1, params.getColumnPos(1));
985        assertEquals("5 key max 4 R1 [3]", -2, params.getColumnPos(2));
986        assertEquals("5 key max 4 R1 [4]", 0, params.getColumnPos(3));
987        assertEquals("5 key max 4 R1 [5]", -1, params.getColumnPos(4));
988        assertEquals("5 key max 4 R1 adjust", 0, params.mTopRowAdjustment);
989        assertEquals("5 key max 4 R1 default", WIDTH * 2, params.getDefaultKeyCoordX());
990    }
991
992    //   [4] [5]   ___|
993    // [3] <1> [2] ___|
994    public void testLayout5KeyMax4R2() {
995        MoreKeysKeyboardParams params = createParams(5, 4, XPOS_R2);
996        assertEquals("5 key max 4 R2 columns", 3, params.mNumColumns);
997        assertEquals("5 key max 4 R2 rows", 2, params.mNumRows);
998        assertEquals("5 key max 4 R2 left", 1, params.mLeftKeys);
999        assertEquals("5 key max 4 R2 right", 2, params.mRightKeys);
1000        assertEquals("5 key max 4 R2 <1>", 0, params.getColumnPos(0));
1001        assertEquals("5 key max 4 R2 [2]", 1, params.getColumnPos(1));
1002        assertEquals("5 key max 4 R2 [3]", -1, params.getColumnPos(2));
1003        assertEquals("5 key max 4 R2 [4]", 0, params.getColumnPos(3));
1004        assertEquals("5 key max 4 R2 [5]", 1, params.getColumnPos(4));
1005        assertEquals("5 key max 4 R2 adjust", -1, params.mTopRowAdjustment);
1006        assertEquals("5 key max 4 R2 default", WIDTH * 1, params.getDefaultKeyCoordX());
1007    }
1008
1009    // [5] [3] <1> [2] [4]
1010    public void testLayout5KeyMax5M0() {
1011        MoreKeysKeyboardParams params = createParams(5, 5, XPOS_M0);
1012        assertEquals("5 key max 5 M0 columns", 5, params.mNumColumns);
1013        assertEquals("5 key max 5 M0 rows", 1, params.mNumRows);
1014        assertEquals("5 key max 5 M0 left", 2, params.mLeftKeys);
1015        assertEquals("5 key max 5 M0 right", 3, params.mRightKeys);
1016        assertEquals("5 key max 5 M0 <1>", 0, params.getColumnPos(0));
1017        assertEquals("5 key max 5 M0 [2]", 1, params.getColumnPos(1));
1018        assertEquals("5 key max 5 M0 [3]", -1, params.getColumnPos(2));
1019        assertEquals("5 key max 5 M0 [4]", 2, params.getColumnPos(3));
1020        assertEquals("5 key max 5 M0 [5]", -2, params.getColumnPos(4));
1021        assertEquals("5 key max 5 M0 adjust", 0, params.mTopRowAdjustment);
1022        assertEquals("5 key max 5 M0 default", WIDTH * 2, params.getDefaultKeyCoordX());
1023    }
1024
1025    // |<1> [2] [3] [4] [5]
1026    public void testLayout5KeyMax5L0() {
1027        MoreKeysKeyboardParams params = createParams(5, 5, XPOS_L0);
1028        assertEquals("5 key max 5 L0 columns", 5, params.mNumColumns);
1029        assertEquals("5 key max 5 L0 rows", 1, params.mNumRows);
1030        assertEquals("5 key max 5 L0 left", 0, params.mLeftKeys);
1031        assertEquals("5 key max 5 L0 right", 5, params.mRightKeys);
1032        assertEquals("5 key max 5 L0 <1>", 0, params.getColumnPos(0));
1033        assertEquals("5 key max 5 L0 [2]", 1, params.getColumnPos(1));
1034        assertEquals("5 key max 5 L0 [3]", 2, params.getColumnPos(2));
1035        assertEquals("5 key max 5 L0 [4]", 3, params.getColumnPos(3));
1036        assertEquals("5 key max 5 L0 [5]", 4, params.getColumnPos(4));
1037        assertEquals("5 key max 5 L0 adjust", 0, params.mTopRowAdjustment);
1038        assertEquals("5 key max 5 L0 default", WIDTH * 0, params.getDefaultKeyCoordX());
1039    }
1040
1041    // |___ <1> [2] [3] [4] [5]
1042    public void testLayout5KeyMax5L1() {
1043        MoreKeysKeyboardParams params = createParams(5, 5, XPOS_L1);
1044        assertEquals("5 key max 5 L1 columns", 5, params.mNumColumns);
1045        assertEquals("5 key max 5 L1 rows", 1, params.mNumRows);
1046        assertEquals("5 key max 5 L1 left", 0, params.mLeftKeys);
1047        assertEquals("5 key max 5 L1 right", 5, params.mRightKeys);
1048        assertEquals("5 key max 5 L1 <1>", 0, params.getColumnPos(0));
1049        assertEquals("5 key max 5 L1 [2]", 1, params.getColumnPos(1));
1050        assertEquals("5 key max 5 L1 [3]", 2, params.getColumnPos(2));
1051        assertEquals("5 key max 5 L1 [4]", 3, params.getColumnPos(3));
1052        assertEquals("5 key max 5 L1 [5]", 4, params.getColumnPos(4));
1053        assertEquals("5 key max 5 L1 adjust", 0, params.mTopRowAdjustment);
1054        assertEquals("5 key max 5 L1 default", WIDTH * 0, params.getDefaultKeyCoordX());
1055    }
1056
1057    // |___ [3] <1> [2] [4] [5]
1058    public void testLayout5KeyMax5L2() {
1059        MoreKeysKeyboardParams params = createParams(5, 5, XPOS_L2);
1060        assertEquals("5 key max 5 L2 columns", 5, params.mNumColumns);
1061        assertEquals("5 key max 5 L2 rows", 1, params.mNumRows);
1062        assertEquals("5 key max 5 L2 left", 1, params.mLeftKeys);
1063        assertEquals("5 key max 5 L2 right", 4, params.mRightKeys);
1064        assertEquals("5 key max 5 L2 <1>", 0, params.getColumnPos(0));
1065        assertEquals("5 key max 5 L2 [2]", 1, params.getColumnPos(1));
1066        assertEquals("5 key max 5 L2 [3]", -1, params.getColumnPos(2));
1067        assertEquals("5 key max 5 L2 [4]", 2, params.getColumnPos(3));
1068        assertEquals("5 key max 5 L2 [5]", 3, params.getColumnPos(4));
1069        assertEquals("5 key max 5 L2 adjust", 0, params.mTopRowAdjustment);
1070        assertEquals("5 key max 5 L2 default", WIDTH * 1, params.getDefaultKeyCoordX());
1071    }
1072
1073    // [5] [4] [3] [2] <1>|
1074    public void testLayout5KeyMax5R0() {
1075        MoreKeysKeyboardParams params = createParams(5, 5, XPOS_R0);
1076        assertEquals("5 key max 5 R0 columns", 5, params.mNumColumns);
1077        assertEquals("5 key max 5 R0 rows", 1, params.mNumRows);
1078        assertEquals("5 key max 5 R0 left", 4, params.mLeftKeys);
1079        assertEquals("5 key max 5 R0 right", 1, params.mRightKeys);
1080        assertEquals("5 key max 5 R0 <1>", 0, params.getColumnPos(0));
1081        assertEquals("5 key max 5 R0 [2]", -1, params.getColumnPos(1));
1082        assertEquals("5 key max 5 R0 [3]", -2, params.getColumnPos(2));
1083        assertEquals("5 key max 5 R0 [4]", -3, params.getColumnPos(3));
1084        assertEquals("5 key max 5 R0 [5]", -4, params.getColumnPos(4));
1085        assertEquals("5 key max 5 R0 adjust", 0, params.mTopRowAdjustment);
1086        assertEquals("5 key max 5 R0 default", WIDTH * 4, params.getDefaultKeyCoordX());
1087    }
1088
1089    // [5] [4] [3] [2] <1> ___|
1090    public void testLayout5KeyMax5R1() {
1091        MoreKeysKeyboardParams params = createParams(5, 5, XPOS_R1);
1092        assertEquals("5 key max 5 R1 columns", 5, params.mNumColumns);
1093        assertEquals("5 key max 5 R1 rows", 1, params.mNumRows);
1094        assertEquals("5 key max 5 R1 left", 4, params.mLeftKeys);
1095        assertEquals("5 key max 5 R1 right", 1, params.mRightKeys);
1096        assertEquals("5 key max 5 R1 <1>", 0, params.getColumnPos(0));
1097        assertEquals("5 key max 5 R1 [2]", -1, params.getColumnPos(1));
1098        assertEquals("5 key max 5 R1 [3]", -2, params.getColumnPos(2));
1099        assertEquals("5 key max 5 R1 [4]", -3, params.getColumnPos(3));
1100        assertEquals("5 key max 5 R1 [5]", -4, params.getColumnPos(4));
1101        assertEquals("5 key max 5 R1 adjust", 0, params.mTopRowAdjustment);
1102        assertEquals("5 key max 5 R1 default", WIDTH * 4, params.getDefaultKeyCoordX());
1103    }
1104
1105    // [5] [4] [3] <1> [2] ___|
1106    public void testLayout5KeyMax5R2() {
1107        MoreKeysKeyboardParams params = createParams(5, 5, XPOS_R2);
1108        assertEquals("5 key max 5 R2 columns", 5, params.mNumColumns);
1109        assertEquals("5 key max 5 R2 rows", 1, params.mNumRows);
1110        assertEquals("5 key max 5 R2 left", 3, params.mLeftKeys);
1111        assertEquals("5 key max 5 R2 right", 2, params.mRightKeys);
1112        assertEquals("5 key max 5 R2 <1>", 0, params.getColumnPos(0));
1113        assertEquals("5 key max 5 R2 [2]", 1, params.getColumnPos(1));
1114        assertEquals("5 key max 5 R2 [3]", -1, params.getColumnPos(2));
1115        assertEquals("5 key max 5 R2 [4]", -2, params.getColumnPos(3));
1116        assertEquals("5 key max 5 R2 [5]", -3, params.getColumnPos(4));
1117        assertEquals("5 key max 5 R2 adjust", 0, params.mTopRowAdjustment);
1118        assertEquals("5 key max 5 R2 default", WIDTH * 3, params.getDefaultKeyCoordX());
1119    }
1120
1121    // [6] [4] [5]
1122    // [3] <1> [2]
1123    public void testLayout6KeyMax4M0() {
1124        MoreKeysKeyboardParams params = createParams(6, 4, XPOS_M0);
1125        assertEquals("6 key max 4 M0 columns", 3, params.mNumColumns);
1126        assertEquals("6 key max 4 M0 rows", 2, params.mNumRows);
1127        assertEquals("6 key max 4 M0 left", 1, params.mLeftKeys);
1128        assertEquals("6 key max 4 M0 right", 2, params.mRightKeys);
1129        assertEquals("6 key max 4 M0 <1>", 0, params.getColumnPos(0));
1130        assertEquals("6 key max 4 M0 [2]", 1, params.getColumnPos(1));
1131        assertEquals("6 key max 4 M0 [3]", -1, params.getColumnPos(2));
1132        assertEquals("6 key max 4 M0 [4]", 0, params.getColumnPos(3));
1133        assertEquals("6 key max 4 M0 [5]", 1, params.getColumnPos(4));
1134        assertEquals("6 key max 4 M0 [6]", -1, params.getColumnPos(5));
1135        assertEquals("6 key max 4 M0 adjust", 0, params.mTopRowAdjustment);
1136        assertEquals("6 key max 4 M0 default", WIDTH * 1, params.getDefaultKeyCoordX());
1137    }
1138
1139    // |[4] [5] [6]
1140    // |<1> [2] [3]
1141    public void testLayout6KeyMax4L0() {
1142        MoreKeysKeyboardParams params = createParams(6, 4, XPOS_L0);
1143        assertEquals("6 key max 4 L0 columns", 3, params.mNumColumns);
1144        assertEquals("6 key max 4 L0 rows", 2, params.mNumRows);
1145        assertEquals("6 key max 4 L0 left", 0, params.mLeftKeys);
1146        assertEquals("6 key max 4 L0 right", 3, params.mRightKeys);
1147        assertEquals("6 key max 4 L0 <1>", 0, params.getColumnPos(0));
1148        assertEquals("6 key max 4 L0 [2]", 1, params.getColumnPos(1));
1149        assertEquals("6 key max 4 L0 [3]", 2, params.getColumnPos(2));
1150        assertEquals("6 key max 4 L0 [4]", 0, params.getColumnPos(3));
1151        assertEquals("6 key max 4 L0 [5]", 1, params.getColumnPos(4));
1152        assertEquals("6 key max 4 L0 [6]", 2, params.getColumnPos(5));
1153        assertEquals("6 key max 4 L0 adjust", 0, params.mTopRowAdjustment);
1154        assertEquals("6 key max 4 L0 default", WIDTH * 0, params.getDefaultKeyCoordX());
1155    }
1156
1157    // |___ [4] [5] [6]
1158    // |___ <1> [2] [3]
1159    public void testLayout6KeyMax4L1() {
1160        MoreKeysKeyboardParams params = createParams(6, 4, XPOS_L1);
1161        assertEquals("6 key max 4 L1 columns", 3, params.mNumColumns);
1162        assertEquals("6 key max 4 L1 rows", 2, params.mNumRows);
1163        assertEquals("6 key max 4 L1 left", 0, params.mLeftKeys);
1164        assertEquals("6 key max 4 L1 right", 3, params.mRightKeys);
1165        assertEquals("6 key max 4 L1 <1>", 0, params.getColumnPos(0));
1166        assertEquals("6 key max 4 L1 [2]", 1, params.getColumnPos(1));
1167        assertEquals("6 key max 4 L1 [3]", 2, params.getColumnPos(2));
1168        assertEquals("6 key max 4 L1 [4]", 0, params.getColumnPos(3));
1169        assertEquals("6 key max 4 L1 [5]", 1, params.getColumnPos(4));
1170        assertEquals("6 key max 4 L1 [6]", 2, params.getColumnPos(5));
1171        assertEquals("6 key max 4 L1 adjust", 0, params.mTopRowAdjustment);
1172        assertEquals("6 key max 4 L1 default", WIDTH * 0, params.getDefaultKeyCoordX());
1173    }
1174
1175    // |___ [6] [4] [5]
1176    // |___ [3] <1> [2]
1177    public void testLayout6KeyMax4L2() {
1178        MoreKeysKeyboardParams params = createParams(6, 4, XPOS_L2);
1179        assertEquals("6 key max 4 L2 columns", 3, params.mNumColumns);
1180        assertEquals("6 key max 4 L2 rows", 2, params.mNumRows);
1181        assertEquals("6 key max 4 L2 left", 1, params.mLeftKeys);
1182        assertEquals("6 key max 4 L2 right", 2, params.mRightKeys);
1183        assertEquals("6 key max 4 L2 <1>", 0, params.getColumnPos(0));
1184        assertEquals("6 key max 4 L2 [2]", 1, params.getColumnPos(1));
1185        assertEquals("6 key max 4 L2 [3]", -1, params.getColumnPos(2));
1186        assertEquals("6 key max 4 L2 [4]", 0, params.getColumnPos(3));
1187        assertEquals("6 key max 4 L2 [5]", 1, params.getColumnPos(4));
1188        assertEquals("6 key max 4 L2 [6]", -1, params.getColumnPos(5));
1189        assertEquals("6 key max 4 L2 adjust", 0, params.mTopRowAdjustment);
1190        assertEquals("6 key max 4 L2 default", WIDTH * 1, params.getDefaultKeyCoordX());
1191    }
1192
1193    // [6] [5] [4]|
1194    // [3] [2] <1>|
1195    public void testLayout6KeyMax4R0() {
1196        MoreKeysKeyboardParams params = createParams(6, 4, XPOS_R0);
1197        assertEquals("6 key max 4 R0 columns", 3, params.mNumColumns);
1198        assertEquals("6 key max 4 R0 rows", 2, params.mNumRows);
1199        assertEquals("6 key max 4 R0 left", 2, params.mLeftKeys);
1200        assertEquals("6 key max 4 R0 right", 1, params.mRightKeys);
1201        assertEquals("6 key max 4 R0 <1>", 0, params.getColumnPos(0));
1202        assertEquals("6 key max 4 R0 [2]", -1, params.getColumnPos(1));
1203        assertEquals("6 key max 4 R0 [3]", -2, params.getColumnPos(2));
1204        assertEquals("6 key max 4 R0 [4]", 0, params.getColumnPos(3));
1205        assertEquals("6 key max 4 R0 [5]", -1, params.getColumnPos(4));
1206        assertEquals("6 key max 4 R0 [6]", -2, params.getColumnPos(5));
1207        assertEquals("6 key max 4 R0 adjust", 0, params.mTopRowAdjustment);
1208        assertEquals("6 key max 4 R0 default", WIDTH * 2, params.getDefaultKeyCoordX());
1209    }
1210
1211    // [6] [5] [4] ___|
1212    // [3] [2] <1> ___|
1213    public void testLayout6KeyMax4R1() {
1214        MoreKeysKeyboardParams params = createParams(6, 4, XPOS_R1);
1215        assertEquals("6 key max 4 R1 columns", 3, params.mNumColumns);
1216        assertEquals("6 key max 4 R1 rows", 2, params.mNumRows);
1217        assertEquals("6 key max 4 R1 left", 2, params.mLeftKeys);
1218        assertEquals("6 key max 4 R1 right", 1, params.mRightKeys);
1219        assertEquals("6 key max 4 R1 <1>", 0, params.getColumnPos(0));
1220        assertEquals("6 key max 4 R1 [2]", -1, params.getColumnPos(1));
1221        assertEquals("6 key max 4 R1 [3]", -2, params.getColumnPos(2));
1222        assertEquals("6 key max 4 R1 [4]", 0, params.getColumnPos(3));
1223        assertEquals("6 key max 4 R1 [5]", -1, params.getColumnPos(4));
1224        assertEquals("6 key max 4 R1 [6]", -2, params.getColumnPos(5));
1225        assertEquals("6 key max 4 R1 adjust", 0, params.mTopRowAdjustment);
1226        assertEquals("6 key max 4 R1 default", WIDTH * 2, params.getDefaultKeyCoordX());
1227    }
1228
1229    // [6] [4] [5] ___|
1230    // [3] <1> [2] ___|
1231    public void testLayout6KeyMax4R2() {
1232        MoreKeysKeyboardParams params = createParams(6, 4, XPOS_R2);
1233        assertEquals("6 key max 4 R2 columns", 3, params.mNumColumns);
1234        assertEquals("6 key max 4 R2 rows", 2, params.mNumRows);
1235        assertEquals("6 key max 4 R2 left", 1, params.mLeftKeys);
1236        assertEquals("6 key max 4 R2 right", 2, params.mRightKeys);
1237        assertEquals("6 key max 4 R2 <1>", 0, params.getColumnPos(0));
1238        assertEquals("6 key max 4 R2 [2]", 1, params.getColumnPos(1));
1239        assertEquals("6 key max 4 R2 [3]", -1, params.getColumnPos(2));
1240        assertEquals("6 key max 4 R2 [4]", 0, params.getColumnPos(3));
1241        assertEquals("6 key max 4 R2 [5]", 1, params.getColumnPos(4));
1242        assertEquals("6 key max 4 R2 [6]", -1, params.getColumnPos(5));
1243        assertEquals("6 key max 4 R2 adjust", 0, params.mTopRowAdjustment);
1244        assertEquals("6 key max 4 R2 default", WIDTH * 1, params.getDefaultKeyCoordX());
1245    }
1246
1247    // [6] [4] [5]
1248    // [3] <1> [2]
1249    public void testLayout6KeyMax5M0() {
1250        MoreKeysKeyboardParams params = createParams(6, 5, XPOS_M0);
1251        assertEquals("6 key max 5 M0 columns", 3, params.mNumColumns);
1252        assertEquals("6 key max 5 M0 rows", 2, params.mNumRows);
1253        assertEquals("6 key max 5 M0 left", 1, params.mLeftKeys);
1254        assertEquals("6 key max 5 M0 right", 2, params.mRightKeys);
1255        assertEquals("6 key max 5 M0 <1>", 0, params.getColumnPos(0));
1256        assertEquals("6 key max 5 M0 [2]", 1, params.getColumnPos(1));
1257        assertEquals("6 key max 5 M0 [3]", -1, params.getColumnPos(2));
1258        assertEquals("6 key max 5 M0 [4]", 0, params.getColumnPos(3));
1259        assertEquals("6 key max 5 M0 [5]", 1, params.getColumnPos(4));
1260        assertEquals("6 key max 5 M0 [6]", -1, params.getColumnPos(5));
1261        assertEquals("6 key max 5 M0 adjust", 0, params.mTopRowAdjustment);
1262        assertEquals("6 key max 5 M0 default", WIDTH * 1, params.getDefaultKeyCoordX());
1263    }
1264
1265    // |[4] [5] [6]
1266    // |<1> [2] [3]
1267    public void testLayout6KeyMax5L0() {
1268        MoreKeysKeyboardParams params = createParams(6, 5, XPOS_L0);
1269        assertEquals("6 key max 5 L0 columns", 3, params.mNumColumns);
1270        assertEquals("6 key max 5 L0 rows", 2, params.mNumRows);
1271        assertEquals("6 key max 5 L0 left", 0, params.mLeftKeys);
1272        assertEquals("6 key max 5 L0 right", 3, params.mRightKeys);
1273        assertEquals("6 key max 5 L0 <1>", 0, params.getColumnPos(0));
1274        assertEquals("6 key max 5 L0 [2]", 1, params.getColumnPos(1));
1275        assertEquals("6 key max 5 L0 [3]", 2, params.getColumnPos(2));
1276        assertEquals("6 key max 5 L0 [4]", 0, params.getColumnPos(3));
1277        assertEquals("6 key max 5 L0 [5]", 1, params.getColumnPos(4));
1278        assertEquals("6 key max 5 L0 [6]", 2, params.getColumnPos(5));
1279        assertEquals("6 key max 5 L0 adjust", 0, params.mTopRowAdjustment);
1280        assertEquals("6 key max 5 L0 default", WIDTH * 0, params.getDefaultKeyCoordX());
1281    }
1282
1283    // |___ [4] [5] [6]
1284    // |___ <1> [2] [3]
1285    public void testLayout6KeyMax5L1() {
1286        MoreKeysKeyboardParams params = createParams(6, 5, XPOS_L1);
1287        assertEquals("6 key max 5 L1 columns", 3, params.mNumColumns);
1288        assertEquals("6 key max 5 L1 rows", 2, params.mNumRows);
1289        assertEquals("6 key max 5 L1 left", 0, params.mLeftKeys);
1290        assertEquals("6 key max 5 L1 right", 3, params.mRightKeys);
1291        assertEquals("6 key max 5 L1 <1>", 0, params.getColumnPos(0));
1292        assertEquals("6 key max 5 L1 [2]", 1, params.getColumnPos(1));
1293        assertEquals("6 key max 5 L1 [3]", 2, params.getColumnPos(2));
1294        assertEquals("6 key max 5 L1 [4]", 0, params.getColumnPos(3));
1295        assertEquals("6 key max 5 L1 [5]", 1, params.getColumnPos(4));
1296        assertEquals("6 key max 5 L1 [6]", 2, params.getColumnPos(5));
1297        assertEquals("6 key max 5 L1 adjust", 0, params.mTopRowAdjustment);
1298        assertEquals("6 key max 5 L1 default", WIDTH * 0, params.getDefaultKeyCoordX());
1299    }
1300
1301    // |___ [6] [4] [5]
1302    // |___ [3] <1> [2]
1303    public void testLayout6KeyMax5L2() {
1304        MoreKeysKeyboardParams params = createParams(6, 5, XPOS_L2);
1305        assertEquals("6 key max 5 L2 columns", 3, params.mNumColumns);
1306        assertEquals("6 key max 5 L2 rows", 2, params.mNumRows);
1307        assertEquals("6 key max 5 L2 left", 1, params.mLeftKeys);
1308        assertEquals("6 key max 5 L2 right", 2, params.mRightKeys);
1309        assertEquals("6 key max 5 L2 <1>", 0, params.getColumnPos(0));
1310        assertEquals("6 key max 5 L2 [2]", 1, params.getColumnPos(1));
1311        assertEquals("6 key max 5 L2 [3]", -1, params.getColumnPos(2));
1312        assertEquals("6 key max 5 L2 [4]", 0, params.getColumnPos(3));
1313        assertEquals("6 key max 5 L2 [5]", 1, params.getColumnPos(4));
1314        assertEquals("6 key max 5 L2 [6]", -1, params.getColumnPos(5));
1315        assertEquals("6 key max 5 L2 adjust", 0, params.mTopRowAdjustment);
1316        assertEquals("6 key max 5 L2 default", WIDTH * 1, params.getDefaultKeyCoordX());
1317    }
1318
1319    // [6] [5] [4]|
1320    // [3] [2] <1>|
1321    public void testLayout6KeyMax5R0() {
1322        MoreKeysKeyboardParams params = createParams(6, 5, XPOS_R0);
1323        assertEquals("6 key max 5 R0 columns", 3, params.mNumColumns);
1324        assertEquals("6 key max 5 R0 rows", 2, params.mNumRows);
1325        assertEquals("6 key max 5 R0 left", 2, params.mLeftKeys);
1326        assertEquals("6 key max 5 R0 right", 1, params.mRightKeys);
1327        assertEquals("6 key max 5 R0 <1>", 0, params.getColumnPos(0));
1328        assertEquals("6 key max 5 R0 [2]", -1, params.getColumnPos(1));
1329        assertEquals("6 key max 5 R0 [3]", -2, params.getColumnPos(2));
1330        assertEquals("6 key max 5 R0 [4]", 0, params.getColumnPos(3));
1331        assertEquals("6 key max 5 R0 [5]", -1, params.getColumnPos(4));
1332        assertEquals("6 key max 5 R0 [6]", -2, params.getColumnPos(5));
1333        assertEquals("6 key max 5 R0 adjust", 0, params.mTopRowAdjustment);
1334        assertEquals("6 key max 5 R0 default", WIDTH * 2, params.getDefaultKeyCoordX());
1335    }
1336
1337    // [6] [5] [4] ___|
1338    // [3] [2] <1> ___|
1339    public void testLayout6KeyMax5R1() {
1340        MoreKeysKeyboardParams params = createParams(6, 5, XPOS_R1);
1341        assertEquals("6 key max 5 R1 columns", 3, params.mNumColumns);
1342        assertEquals("6 key max 5 R1 rows", 2, params.mNumRows);
1343        assertEquals("6 key max 5 R1 left", 2, params.mLeftKeys);
1344        assertEquals("6 key max 5 R1 right", 1, params.mRightKeys);
1345        assertEquals("6 key max 5 R1 <1>", 0, params.getColumnPos(0));
1346        assertEquals("6 key max 5 R1 [2]", -1, params.getColumnPos(1));
1347        assertEquals("6 key max 5 R1 [3]", -2, params.getColumnPos(2));
1348        assertEquals("6 key max 5 R1 [4]", 0, params.getColumnPos(3));
1349        assertEquals("6 key max 5 R1 [5]", -1, params.getColumnPos(4));
1350        assertEquals("6 key max 5 R1 [6]", -2, params.getColumnPos(5));
1351        assertEquals("6 key max 5 R1 adjust", 0, params.mTopRowAdjustment);
1352        assertEquals("6 key max 5 R1 default", WIDTH * 2, params.getDefaultKeyCoordX());
1353    }
1354
1355    // [6] [4] [5] ___|
1356    // [3] <1> [2] ___|
1357    public void testLayout6KeyMax5R2() {
1358        MoreKeysKeyboardParams params = createParams(6, 5, XPOS_R2);
1359        assertEquals("6 key max 5 R2 columns", 3, params.mNumColumns);
1360        assertEquals("6 key max 5 R2 rows", 2, params.mNumRows);
1361        assertEquals("6 key max 5 R2 left", 1, params.mLeftKeys);
1362        assertEquals("6 key max 5 R2 right", 2, params.mRightKeys);
1363        assertEquals("6 key max 5 R2 <1>", 0, params.getColumnPos(0));
1364        assertEquals("6 key max 5 R2 [2]", 1, params.getColumnPos(1));
1365        assertEquals("6 key max 5 R2 [3]", -1, params.getColumnPos(2));
1366        assertEquals("6 key max 5 R2 [4]", 0, params.getColumnPos(3));
1367        assertEquals("6 key max 5 R2 [5]", 1, params.getColumnPos(4));
1368        assertEquals("6 key max 5 R2 [6]", -1, params.getColumnPos(5));
1369        assertEquals("6 key max 5 R2 adjust", 0, params.mTopRowAdjustment);
1370        assertEquals("6 key max 5 R2 default", WIDTH * 1, params.getDefaultKeyCoordX());
1371    }
1372
1373    // |<1> [2] [3] [4] [5] [6] [7] ___ ___ ___|
1374    public void testLayout7KeyMax7L0() {
1375        MoreKeysKeyboardParams params = createParams(7, 7, XPOS_L0);
1376        assertEquals("7 key max 7 L0 columns", 7, params.mNumColumns);
1377        assertEquals("7 key max 7 L0 rows", 1, params.mNumRows);
1378        assertEquals("7 key max 7 L0 left", 0, params.mLeftKeys);
1379        assertEquals("7 key max 7 L0 right", 7, params.mRightKeys);
1380        assertEquals("7 key max 7 L0 <1>", 0, params.getColumnPos(0));
1381        assertEquals("7 key max 7 L0 [2]", 1, params.getColumnPos(1));
1382        assertEquals("7 key max 7 L0 [3]", 2, params.getColumnPos(2));
1383        assertEquals("7 key max 7 L0 [4]", 3, params.getColumnPos(3));
1384        assertEquals("7 key max 7 L0 [5]", 4, params.getColumnPos(4));
1385        assertEquals("7 key max 7 L0 [6]", 5, params.getColumnPos(5));
1386        assertEquals("7 key max 7 L0 [7]", 6, params.getColumnPos(6));
1387        assertEquals("7 key max 7 L0 adjust", 0, params.mTopRowAdjustment);
1388        assertEquals("7 key max 7 L0 default", WIDTH * 0, params.getDefaultKeyCoordX());
1389    }
1390
1391    // |___ <1> [2] [3] [4] [5] [6] [7] ___ ___|
1392    public void testLayout7KeyMax7L1() {
1393        MoreKeysKeyboardParams params = createParams(7, 7, XPOS_L1);
1394        assertEquals("7 key max 7 L1 columns", 7, params.mNumColumns);
1395        assertEquals("7 key max 7 L1 rows", 1, params.mNumRows);
1396        assertEquals("7 key max 7 L1 left", 0, params.mLeftKeys);
1397        assertEquals("7 key max 7 L1 right", 7, params.mRightKeys);
1398        assertEquals("7 key max 7 L1 <1>", 0, params.getColumnPos(0));
1399        assertEquals("7 key max 7 L1 [2]", 1, params.getColumnPos(1));
1400        assertEquals("7 key max 7 L1 [3]", 2, params.getColumnPos(2));
1401        assertEquals("7 key max 7 L1 [4]", 3, params.getColumnPos(3));
1402        assertEquals("7 key max 7 L1 [5]", 4, params.getColumnPos(4));
1403        assertEquals("7 key max 7 L1 [6]", 5, params.getColumnPos(5));
1404        assertEquals("7 key max 7 L1 [7]", 6, params.getColumnPos(6));
1405        assertEquals("7 key max 7 L1 adjust", 0, params.mTopRowAdjustment);
1406        assertEquals("7 key max 7 L1 default", WIDTH * 0, params.getDefaultKeyCoordX());
1407    }
1408
1409    // |___ [3] <1> [2] [4] [5] [6] [7] ___ ___|
1410    public void testLayout7KeyMax7L2() {
1411        MoreKeysKeyboardParams params = createParams(7, 7, XPOS_L2);
1412        assertEquals("7 key max 7 L2 columns", 7, params.mNumColumns);
1413        assertEquals("7 key max 7 L2 rows", 1, params.mNumRows);
1414        assertEquals("7 key max 7 L2 left", 1, params.mLeftKeys);
1415        assertEquals("7 key max 7 L2 right", 6, params.mRightKeys);
1416        assertEquals("7 key max 7 L2 <1>", 0, params.getColumnPos(0));
1417        assertEquals("7 key max 7 L2 [2]", 1, params.getColumnPos(1));
1418        assertEquals("7 key max 7 L2 [3]", -1, params.getColumnPos(2));
1419        assertEquals("7 key max 7 L2 [4]", 2, params.getColumnPos(3));
1420        assertEquals("7 key max 7 L2 [5]", 3, params.getColumnPos(4));
1421        assertEquals("7 key max 7 L2 [6]", 4, params.getColumnPos(5));
1422        assertEquals("7 key max 7 L2 [7]", 5, params.getColumnPos(6));
1423        assertEquals("7 key max 7 L2 adjust", 0, params.mTopRowAdjustment);
1424        assertEquals("7 key max 7 L2 default", WIDTH * 1, params.getDefaultKeyCoordX());
1425    }
1426
1427    // |___ [5] [3] <1> [2] [4] [6] [7] ___ ___|
1428    public void testLayout7KeyMax7L3() {
1429        MoreKeysKeyboardParams params = createParams(7, 7, XPOS_L3);
1430        assertEquals("7 key max 7 L3 columns", 7, params.mNumColumns);
1431        assertEquals("7 key max 7 L3 rows", 1, params.mNumRows);
1432        assertEquals("7 key max 7 L3 left", 2, params.mLeftKeys);
1433        assertEquals("7 key max 7 L3 right", 5, params.mRightKeys);
1434        assertEquals("7 key max 7 L3 <1>", 0, params.getColumnPos(0));
1435        assertEquals("7 key max 7 L3 [2]", 1, params.getColumnPos(1));
1436        assertEquals("7 key max 7 L3 [3]", -1, params.getColumnPos(2));
1437        assertEquals("7 key max 7 L3 [4]", 2, params.getColumnPos(3));
1438        assertEquals("7 key max 7 L3 [5]", -2, params.getColumnPos(4));
1439        assertEquals("7 key max 7 L3 [6]", 3, params.getColumnPos(5));
1440        assertEquals("7 key max 7 L3 [7]", 4, params.getColumnPos(6));
1441        assertEquals("7 key max 7 L3 adjust", 0, params.mTopRowAdjustment);
1442        assertEquals("7 key max 7 L3 default", WIDTH * 2, params.getDefaultKeyCoordX());
1443    }
1444
1445    // |___ [7] [5] [3] <1> [2] [4] [6] ___ ___|
1446    public void testLayout7KeyMax7M0() {
1447        MoreKeysKeyboardParams params = createParams(7, 7, XPOS_M0);
1448        assertEquals("7 key max 7 M0 columns", 7, params.mNumColumns);
1449        assertEquals("7 key max 7 M0 rows", 1, params.mNumRows);
1450        assertEquals("7 key max 7 M0 left", 3, params.mLeftKeys);
1451        assertEquals("7 key max 7 M0 right", 4, params.mRightKeys);
1452        assertEquals("7 key max 7 M0 <1>", 0, params.getColumnPos(0));
1453        assertEquals("7 key max 7 M0 [2]", 1, params.getColumnPos(1));
1454        assertEquals("7 key max 7 M0 [3]", -1, params.getColumnPos(2));
1455        assertEquals("7 key max 7 M0 [4]", 2, params.getColumnPos(3));
1456        assertEquals("7 key max 7 M0 [5]", -2, params.getColumnPos(4));
1457        assertEquals("7 key max 7 M0 [6]", 3, params.getColumnPos(5));
1458        assertEquals("7 key max 7 M0 [7]", -3, params.getColumnPos(6));
1459        assertEquals("7 key max 7 M0 adjust", 0, params.mTopRowAdjustment);
1460        assertEquals("7 key max 7 M0 default", WIDTH * 3, params.getDefaultKeyCoordX());
1461    }
1462
1463    // |___ ___ [7] [5] [3] <1> [2] [4] [6] ___|
1464    public void testLayout7KeyMax7M1() {
1465        MoreKeysKeyboardParams params = createParams(7, 7, XPOS_M1);
1466        assertEquals("7 key max 7 M1 columns", 7, params.mNumColumns);
1467        assertEquals("7 key max 7 M1 rows", 1, params.mNumRows);
1468        assertEquals("7 key max 7 M1 left", 3, params.mLeftKeys);
1469        assertEquals("7 key max 7 M1 right", 4, params.mRightKeys);
1470        assertEquals("7 key max 7 M1 <1>", 0, params.getColumnPos(0));
1471        assertEquals("7 key max 7 M1 [2]", 1, params.getColumnPos(1));
1472        assertEquals("7 key max 7 M1 [3]", -1, params.getColumnPos(2));
1473        assertEquals("7 key max 7 M1 [4]", 2, params.getColumnPos(3));
1474        assertEquals("7 key max 7 M1 [5]", -2, params.getColumnPos(4));
1475        assertEquals("7 key max 7 M1 [6]", 3, params.getColumnPos(5));
1476        assertEquals("7 key max 7 M1 [7]", -3, params.getColumnPos(6));
1477        assertEquals("7 key max 7 M1 adjust", 0, params.mTopRowAdjustment);
1478        assertEquals("7 key max 7 M1 default", WIDTH * 3, params.getDefaultKeyCoordX());
1479    }
1480
1481    // |___ ___ [7] [6] [5] [3] <1> [2] [4] ___|
1482    public void testLayout7KeyMax7R3() {
1483        MoreKeysKeyboardParams params = createParams(7, 7, XPOS_R3);
1484        assertEquals("7 key max 7 R3 columns", 7, params.mNumColumns);
1485        assertEquals("7 key max 7 R3 rows", 1, params.mNumRows);
1486        assertEquals("7 key max 7 R3 left", 4, params.mLeftKeys);
1487        assertEquals("7 key max 7 R3 right", 3, params.mRightKeys);
1488        assertEquals("7 key max 7 R3 <1>", 0, params.getColumnPos(0));
1489        assertEquals("7 key max 7 R3 [2]", 1, params.getColumnPos(1));
1490        assertEquals("7 key max 7 R3 [3]", -1, params.getColumnPos(2));
1491        assertEquals("7 key max 7 R3 [4]", 2, params.getColumnPos(3));
1492        assertEquals("7 key max 7 R3 [5]", -2, params.getColumnPos(4));
1493        assertEquals("7 key max 7 R3 [6]", -3, params.getColumnPos(5));
1494        assertEquals("7 key max 7 R3 [7]", -4, params.getColumnPos(6));
1495        assertEquals("7 key max 7 R3 adjust", 0, params.mTopRowAdjustment);
1496        assertEquals("7 key max 7 R3 default", WIDTH * 4, params.getDefaultKeyCoordX());
1497    }
1498
1499    // |___ ___ [7] [6] [5] [4] [3] <1> [2] ___|
1500    public void testLayout7KeyMax7R2() {
1501        MoreKeysKeyboardParams params = createParams(7, 7, XPOS_R2);
1502        assertEquals("7 key max 7 R2 columns", 7, params.mNumColumns);
1503        assertEquals("7 key max 7 R2 rows", 1, params.mNumRows);
1504        assertEquals("7 key max 7 R2 left", 5, params.mLeftKeys);
1505        assertEquals("7 key max 7 R2 right", 2, params.mRightKeys);
1506        assertEquals("7 key max 7 R2 <1>", 0, params.getColumnPos(0));
1507        assertEquals("7 key max 7 R2 [2]", 1, params.getColumnPos(1));
1508        assertEquals("7 key max 7 R2 [3]", -1, params.getColumnPos(2));
1509        assertEquals("7 key max 7 R2 [4]", -2, params.getColumnPos(3));
1510        assertEquals("7 key max 7 R2 [5]", -3, params.getColumnPos(4));
1511        assertEquals("7 key max 7 R2 [6]", -4, params.getColumnPos(5));
1512        assertEquals("7 key max 7 R2 [7]", -5, params.getColumnPos(6));
1513        assertEquals("7 key max 7 R2 adjust", 0, params.mTopRowAdjustment);
1514        assertEquals("7 key max 7 R2 default", WIDTH * 5, params.getDefaultKeyCoordX());
1515    }
1516
1517    // |___ ___ [7] [6] [5] [4] [3] [2] <1> ___|
1518    public void testLayout7KeyMax7R1() {
1519        MoreKeysKeyboardParams params = createParams(7, 7, XPOS_R1);
1520        assertEquals("7 key max 7 R1 columns", 7, params.mNumColumns);
1521        assertEquals("7 key max 7 R1 rows", 1, params.mNumRows);
1522        assertEquals("7 key max 7 R1 left", 6, params.mLeftKeys);
1523        assertEquals("7 key max 7 R1 right", 1, params.mRightKeys);
1524        assertEquals("7 key max 7 R1 <1>", 0, params.getColumnPos(0));
1525        assertEquals("7 key max 7 R1 [2]", -1, params.getColumnPos(1));
1526        assertEquals("7 key max 7 R1 [3]", -2, params.getColumnPos(2));
1527        assertEquals("7 key max 7 R1 [4]", -3, params.getColumnPos(3));
1528        assertEquals("7 key max 7 R1 [5]", -4, params.getColumnPos(4));
1529        assertEquals("7 key max 7 R1 [6]", -5, params.getColumnPos(5));
1530        assertEquals("7 key max 7 R1 [7]", -6, params.getColumnPos(6));
1531        assertEquals("7 key max 7 R1 adjust", 0, params.mTopRowAdjustment);
1532        assertEquals("7 key max 7 R1 default", WIDTH * 6, params.getDefaultKeyCoordX());
1533    }
1534
1535    // |___ ___ [7] [6] [5] [4] [3] [2] <1>|
1536    public void testLayout7KeyMax7R0() {
1537        MoreKeysKeyboardParams params = createParams(7, 7, XPOS_R0);
1538        assertEquals("7 key max 7 R0 columns", 7, params.mNumColumns);
1539        assertEquals("7 key max 7 R0 rows", 1, params.mNumRows);
1540        assertEquals("7 key max 7 R0 left", 6, params.mLeftKeys);
1541        assertEquals("7 key max 7 R0 right", 1, params.mRightKeys);
1542        assertEquals("7 key max 7 R0 <1>", 0, params.getColumnPos(0));
1543        assertEquals("7 key max 7 R0 [2]", -1, params.getColumnPos(1));
1544        assertEquals("7 key max 7 R0 [3]", -2, params.getColumnPos(2));
1545        assertEquals("7 key max 7 R0 [4]", -3, params.getColumnPos(3));
1546        assertEquals("7 key max 7 R0 [5]", -4, params.getColumnPos(4));
1547        assertEquals("7 key max 7 R0 [6]", -5, params.getColumnPos(5));
1548        assertEquals("7 key max 7 R0 [7]", -6, params.getColumnPos(6));
1549        assertEquals("7 key max 7 R0 adjust", 0, params.mTopRowAdjustment);
1550        assertEquals("7 key max 7 R0 default", WIDTH * 6, params.getDefaultKeyCoordX());
1551    }
1552
1553    //   [5] [6] [7]
1554    // [3] <1> [2] [4]
1555    public void testLayout7KeyMax5M0() {
1556        MoreKeysKeyboardParams params = createParams(7, 5, XPOS_M0);
1557        assertEquals("7 key max 5 M0 columns", 4, params.mNumColumns);
1558        assertEquals("7 key max 5 M0 rows", 2, params.mNumRows);
1559        assertEquals("7 key max 5 M0 left", 1, params.mLeftKeys);
1560        assertEquals("7 key max 5 M0 right", 3, params.mRightKeys);
1561        assertEquals("7 key max 5 M0 <1>", 0, params.getColumnPos(0));
1562        assertEquals("7 key max 5 M0 [2]", 1, params.getColumnPos(1));
1563        assertEquals("7 key max 5 M0 [3]", -1, params.getColumnPos(2));
1564        assertEquals("7 key max 5 M0 [4]", 2, params.getColumnPos(3));
1565        assertEquals("7 key max 5 M0 [5]", 0, params.getColumnPos(4));
1566        assertEquals("7 key max 5 M0 [6]", 1, params.getColumnPos(5));
1567        assertEquals("7 key max 5 M0 [7]", 2, params.getColumnPos(6));
1568        assertEquals("7 key max 5 M0 adjust", -1, params.mTopRowAdjustment);
1569        assertEquals("7 key max 5 M0 default", WIDTH * 1, params.getDefaultKeyCoordX());
1570    }
1571
1572    // |[5] [6] [7]
1573    // |<1> [2] [3] [4]
1574    public void testLayout7KeyMax5L0() {
1575        MoreKeysKeyboardParams params = createParams(7, 5, XPOS_L0);
1576        assertEquals("7 key max 5 L0 columns", 4, params.mNumColumns);
1577        assertEquals("7 key max 5 L0 rows", 2, params.mNumRows);
1578        assertEquals("7 key max 5 L0 left", 0, params.mLeftKeys);
1579        assertEquals("7 key max 5 L0 right", 4, params.mRightKeys);
1580        assertEquals("7 key max 5 L0 <1>", 0, params.getColumnPos(0));
1581        assertEquals("7 key max 5 L0 [2]", 1, params.getColumnPos(1));
1582        assertEquals("7 key max 5 L0 [3]", 2, params.getColumnPos(2));
1583        assertEquals("7 key max 5 L0 [4]", 3, params.getColumnPos(3));
1584        assertEquals("7 key max 5 L0 [5]", 0, params.getColumnPos(4));
1585        assertEquals("7 key max 5 L0 [6]", 1, params.getColumnPos(5));
1586        assertEquals("7 key max 5 L0 [7]", 2, params.getColumnPos(6));
1587        assertEquals("7 key max 5 L0 adjust", 0, params.mTopRowAdjustment);
1588        assertEquals("7 key max 5 L0 default", WIDTH * 0, params.getDefaultKeyCoordX());
1589    }
1590
1591    // |___ [5] [6] [7]
1592    // |___ <1> [2] [3] [4]
1593    public void testLayout7KeyMax5L1() {
1594        MoreKeysKeyboardParams params = createParams(7, 5, XPOS_L1);
1595        assertEquals("7 key max 5 L1 columns", 4, params.mNumColumns);
1596        assertEquals("7 key max 5 L1 rows", 2, params.mNumRows);
1597        assertEquals("7 key max 5 L1 left", 0, params.mLeftKeys);
1598        assertEquals("7 key max 5 L1 right", 4, params.mRightKeys);
1599        assertEquals("7 key max 5 L1 <1>", 0, params.getColumnPos(0));
1600        assertEquals("7 key max 5 L1 [2]", 1, params.getColumnPos(1));
1601        assertEquals("7 key max 5 L1 [3]", 2, params.getColumnPos(2));
1602        assertEquals("7 key max 5 L1 [4]", 3, params.getColumnPos(3));
1603        assertEquals("7 key max 5 L1 [5]", 0, params.getColumnPos(4));
1604        assertEquals("7 key max 5 L1 [6]", 1, params.getColumnPos(5));
1605        assertEquals("7 key max 5 L1 [7]", 2, params.getColumnPos(6));
1606        assertEquals("7 key max 5 L1 adjust", 0, params.mTopRowAdjustment);
1607        assertEquals("7 key max 5 L1 default", WIDTH * 0, params.getDefaultKeyCoordX());
1608    }
1609
1610    // |___   [5] [6] [7]
1611    // |___ [3] <1> [2] [4]
1612    public void testLayout7KeyMax5L2() {
1613        MoreKeysKeyboardParams params = createParams(7, 5, XPOS_L2);
1614        assertEquals("7 key max 5 L2 columns", 4, params.mNumColumns);
1615        assertEquals("7 key max 5 L2 rows", 2, params.mNumRows);
1616        assertEquals("7 key max 5 L2 left", 1, params.mLeftKeys);
1617        assertEquals("7 key max 5 L2 right", 3, params.mRightKeys);
1618        assertEquals("7 key max 5 L2 <1>", 0, params.getColumnPos(0));
1619        assertEquals("7 key max 5 L2 [2]", 1, params.getColumnPos(1));
1620        assertEquals("7 key max 5 L2 [3]", -1, params.getColumnPos(2));
1621        assertEquals("7 key max 5 L2 [4]", 2, params.getColumnPos(3));
1622        assertEquals("7 key max 5 L2 [5]", 0, params.getColumnPos(4));
1623        assertEquals("7 key max 5 L2 [6]", 1, params.getColumnPos(5));
1624        assertEquals("7 key max 5 L2 [7]", 2, params.getColumnPos(6));
1625        assertEquals("7 key max 5 L2 adjust", -1, params.mTopRowAdjustment);
1626        assertEquals("7 key max 5 L2 default", WIDTH * 1, params.getDefaultKeyCoordX());
1627    }
1628
1629    //     [7] [6] [5]|
1630    // [4] [3] [2] <1>|
1631    public void testLayout7KeyMax5R0() {
1632        MoreKeysKeyboardParams params = createParams(7, 5, XPOS_R0);
1633        assertEquals("7 key max 5 R0 columns", 4, params.mNumColumns);
1634        assertEquals("7 key max 5 R0 rows", 2, params.mNumRows);
1635        assertEquals("7 key max 5 R0 left", 3, params.mLeftKeys);
1636        assertEquals("7 key max 5 R0 right", 1, params.mRightKeys);
1637        assertEquals("7 key max 5 R0 <1>", 0, params.getColumnPos(0));
1638        assertEquals("7 key max 5 R0 [2]", -1, params.getColumnPos(1));
1639        assertEquals("7 key max 5 R0 [3]", -2, params.getColumnPos(2));
1640        assertEquals("7 key max 5 R0 [4]", -3, params.getColumnPos(3));
1641        assertEquals("7 key max 5 R0 [5]", 0, params.getColumnPos(4));
1642        assertEquals("7 key max 5 R0 [6]", -1, params.getColumnPos(5));
1643        assertEquals("7 key max 5 R0 [7]", -2, params.getColumnPos(6));
1644        assertEquals("7 key max 5 R0 adjust", 0, params.mTopRowAdjustment);
1645        assertEquals("7 key max 5 R0 default", WIDTH * 3, params.getDefaultKeyCoordX());
1646    }
1647
1648    //     [7] [6] [5] ___|
1649    // [4] [3] [2] <1> ___|
1650    public void testLayout7KeyMax5R1() {
1651        MoreKeysKeyboardParams params = createParams(7, 5, XPOS_R1);
1652        assertEquals("7 key max 5 R1 columns", 4, params.mNumColumns);
1653        assertEquals("7 key max 5 R1 rows", 2, params.mNumRows);
1654        assertEquals("7 key max 5 R1 left", 3, params.mLeftKeys);
1655        assertEquals("7 key max 5 R1 right", 1, params.mRightKeys);
1656        assertEquals("7 key max 5 R1 <1>", 0, params.getColumnPos(0));
1657        assertEquals("7 key max 5 R1 [2]", -1, params.getColumnPos(1));
1658        assertEquals("7 key max 5 R1 [3]", -2, params.getColumnPos(2));
1659        assertEquals("7 key max 5 R1 [4]", -3, params.getColumnPos(3));
1660        assertEquals("7 key max 5 R1 [5]", 0, params.getColumnPos(4));
1661        assertEquals("7 key max 5 R1 [6]", -1, params.getColumnPos(5));
1662        assertEquals("7 key max 5 R1 [7]", -2, params.getColumnPos(6));
1663        assertEquals("7 key max 5 R1 adjust", 0, params.mTopRowAdjustment);
1664        assertEquals("7 key max 5 R1 default", WIDTH * 3, params.getDefaultKeyCoordX());
1665    }
1666
1667    //   [7] [5] [6]   ___|
1668    // [4] [3] <1> [2] ___|
1669    public void testLayout7KeyMax5R2() {
1670        MoreKeysKeyboardParams params = createParams(7, 5, XPOS_R2);
1671        assertEquals("7 key max 5 R2 columns", 4, params.mNumColumns);
1672        assertEquals("7 key max 5 R2 rows", 2, params.mNumRows);
1673        assertEquals("7 key max 5 R2 left", 2, params.mLeftKeys);
1674        assertEquals("7 key max 5 R2 right", 2, params.mRightKeys);
1675        assertEquals("7 key max 5 R2 <1>", 0, params.getColumnPos(0));
1676        assertEquals("7 key max 5 R2 [2]", 1, params.getColumnPos(1));
1677        assertEquals("7 key max 5 R2 [3]", -1, params.getColumnPos(2));
1678        assertEquals("7 key max 5 R2 [4]", -2, params.getColumnPos(3));
1679        assertEquals("7 key max 5 R2 [5]", 0, params.getColumnPos(4));
1680        assertEquals("7 key max 5 R2 [6]", 1, params.getColumnPos(5));
1681        assertEquals("7 key max 5 R2 [7]", -1, params.getColumnPos(6));
1682        assertEquals("7 key max 5 R2 adjust", -1, params.mTopRowAdjustment);
1683        assertEquals("7 key max 5 R2 default", WIDTH * 2, params.getDefaultKeyCoordX());
1684    }
1685
1686    //     [7]
1687    // [6] [4] [5]
1688    // [3] <1> [2]
1689    public void testLayout7KeyMax3M0() {
1690        MoreKeysKeyboardParams params = createParams(7, 3, XPOS_M0);
1691        assertEquals("7 key max 3 M0 columns", 3, params.mNumColumns);
1692        assertEquals("7 key max 3 M0 rows", 3, params.mNumRows);
1693        assertEquals("7 key max 3 M0 left", 1, params.mLeftKeys);
1694        assertEquals("7 key max 3 M0 right", 2, params.mRightKeys);
1695        assertEquals("7 key max 3 M0 <1>", 0, params.getColumnPos(0));
1696        assertEquals("7 key max 3 M0 [2]", 1, params.getColumnPos(1));
1697        assertEquals("7 key max 3 M0 [3]", -1, params.getColumnPos(2));
1698        assertEquals("7 key max 3 M0 [4]", 0, params.getColumnPos(3));
1699        assertEquals("7 key max 3 M0 [5]", 1, params.getColumnPos(4));
1700        assertEquals("7 key max 3 M0 [6]", -1, params.getColumnPos(5));
1701        assertEquals("7 key max 3 M0 [7]", 0, params.getColumnPos(6));
1702        assertEquals("7 key max 3 M0 adjust", 0, params.mTopRowAdjustment);
1703        assertEquals("7 key max 3 M0 default", WIDTH * 1, params.getDefaultKeyCoordX());
1704    }
1705
1706    // |[7]
1707    // |[4] [5] [6]
1708    // |<1> [2] [3]
1709    public void testLayout7KeyMax3L0() {
1710        MoreKeysKeyboardParams params = createParams(7, 3, XPOS_L0);
1711        assertEquals("7 key max 3 L0 columns", 3, params.mNumColumns);
1712        assertEquals("7 key max 3 L0 rows", 3, params.mNumRows);
1713        assertEquals("7 key max 3 L0 left", 0, params.mLeftKeys);
1714        assertEquals("7 key max 3 L0 right", 3, params.mRightKeys);
1715        assertEquals("7 key max 3 L0 <1>", 0, params.getColumnPos(0));
1716        assertEquals("7 key max 3 L0 [2]", 1, params.getColumnPos(1));
1717        assertEquals("7 key max 3 L0 [3]", 2, params.getColumnPos(2));
1718        assertEquals("7 key max 3 L0 [4]", 0, params.getColumnPos(3));
1719        assertEquals("7 key max 3 L0 [5]", 1, params.getColumnPos(4));
1720        assertEquals("7 key max 3 L0 [6]", 2, params.getColumnPos(5));
1721        assertEquals("7 key max 3 L0 [7]", 0, params.getColumnPos(6));
1722        assertEquals("7 key max 3 L0 adjust", 0, params.mTopRowAdjustment);
1723        assertEquals("7 key max 3 L0 default", WIDTH * 0, params.getDefaultKeyCoordX());
1724    }
1725
1726    // |___ [7]
1727    // |___ [4] [5] [6]
1728    // |___ <1> [2] [3]
1729    public void testLayout7KeyMax3L1() {
1730        MoreKeysKeyboardParams params = createParams(7, 3, XPOS_L1);
1731        assertEquals("7 key max 3 L1 columns", 3, params.mNumColumns);
1732        assertEquals("7 key max 3 L1 rows", 3, params.mNumRows);
1733        assertEquals("7 key max 3 L1 left", 0, params.mLeftKeys);
1734        assertEquals("7 key max 3 L1 right", 3, params.mRightKeys);
1735        assertEquals("7 key max 3 L1 <1>", 0, params.getColumnPos(0));
1736        assertEquals("7 key max 3 L1 [2]", 1, params.getColumnPos(1));
1737        assertEquals("7 key max 3 L1 [3]", 2, params.getColumnPos(2));
1738        assertEquals("7 key max 3 L1 [4]", 0, params.getColumnPos(3));
1739        assertEquals("7 key max 3 L1 [5]", 1, params.getColumnPos(4));
1740        assertEquals("7 key max 3 L1 [6]", 2, params.getColumnPos(5));
1741        assertEquals("7 key max 3 L1 [7]", 0, params.getColumnPos(6));
1742        assertEquals("7 key max 3 L1 adjust", 0, params.mTopRowAdjustment);
1743        assertEquals("7 key max 3 L1 default", WIDTH * 0, params.getDefaultKeyCoordX());
1744    }
1745
1746    // |___     [7]
1747    // |___ [6] [4] [5]
1748    // |___ [3] <1> [2]
1749    public void testLayout7KeyMax3L2() {
1750        MoreKeysKeyboardParams params = createParams(7, 3, XPOS_L2);
1751        assertEquals("7 key max 3 L2 columns", 3, params.mNumColumns);
1752        assertEquals("7 key max 3 L2 rows", 3, params.mNumRows);
1753        assertEquals("7 key max 3 L2 left", 1, params.mLeftKeys);
1754        assertEquals("7 key max 3 L2 right", 2, params.mRightKeys);
1755        assertEquals("7 key max 3 L2 <1>", 0, params.getColumnPos(0));
1756        assertEquals("7 key max 3 L2 [2]", 1, params.getColumnPos(1));
1757        assertEquals("7 key max 3 L2 [3]", -1, params.getColumnPos(2));
1758        assertEquals("7 key max 3 L2 [4]", 0, params.getColumnPos(3));
1759        assertEquals("7 key max 3 L2 [5]", 1, params.getColumnPos(4));
1760        assertEquals("7 key max 3 L2 [6]", -1, params.getColumnPos(5));
1761        assertEquals("7 key max 3 L2 [7]", 0, params.getColumnPos(6));
1762        assertEquals("7 key max 3 L2 adjust", 0, params.mTopRowAdjustment);
1763        assertEquals("7 key max 3 L2 default", WIDTH * 1, params.getDefaultKeyCoordX());
1764    }
1765
1766    //         [7]|
1767    // [6] [5] [4]|
1768    // [3] [2] <1>|
1769    public void testLayout7KeyMax3R0() {
1770        MoreKeysKeyboardParams params = createParams(7, 3, XPOS_R0);
1771        assertEquals("7 key max 3 R0 columns", 3, params.mNumColumns);
1772        assertEquals("7 key max 3 R0 rows", 3, params.mNumRows);
1773        assertEquals("7 key max 3 R0 left", 2, params.mLeftKeys);
1774        assertEquals("7 key max 3 R0 right", 1, params.mRightKeys);
1775        assertEquals("7 key max 3 R0 <1>", 0, params.getColumnPos(0));
1776        assertEquals("7 key max 3 R0 [2]", -1, params.getColumnPos(1));
1777        assertEquals("7 key max 3 R0 [3]", -2, params.getColumnPos(2));
1778        assertEquals("7 key max 3 R0 [4]", 0, params.getColumnPos(3));
1779        assertEquals("7 key max 3 R0 [5]", -1, params.getColumnPos(4));
1780        assertEquals("7 key max 3 R0 [6]", -2, params.getColumnPos(5));
1781        assertEquals("7 key max 3 R0 [7]", 0, params.getColumnPos(6));
1782        assertEquals("7 key max 3 R0 adjust", 0, params.mTopRowAdjustment);
1783        assertEquals("7 key max 3 R0 default", WIDTH * 2, params.getDefaultKeyCoordX());
1784    }
1785
1786    //         [7] ___|
1787    // [6] [5] [4] ___|
1788    // [3] [2] <1> ___|
1789    public void testLayout7KeyMax3R1() {
1790        MoreKeysKeyboardParams params = createParams(7, 3, XPOS_R1);
1791        assertEquals("7 key max 3 R1 columns", 3, params.mNumColumns);
1792        assertEquals("7 key max 3 R1 rows", 3, params.mNumRows);
1793        assertEquals("7 key max 3 R1 left", 2, params.mLeftKeys);
1794        assertEquals("7 key max 3 R1 right", 1, params.mRightKeys);
1795        assertEquals("7 key max 3 R1 <1>", 0, params.getColumnPos(0));
1796        assertEquals("7 key max 3 R1 [2]", -1, params.getColumnPos(1));
1797        assertEquals("7 key max 3 R1 [3]", -2, params.getColumnPos(2));
1798        assertEquals("7 key max 3 R1 [4]", 0, params.getColumnPos(3));
1799        assertEquals("7 key max 3 R1 [5]", -1, params.getColumnPos(4));
1800        assertEquals("7 key max 3 R1 [6]", -2, params.getColumnPos(5));
1801        assertEquals("7 key max 3 R1 [7]", 0, params.getColumnPos(6));
1802        assertEquals("7 key max 3 R1 adjust", 0, params.mTopRowAdjustment);
1803        assertEquals("7 key max 3 R1 default", WIDTH * 2, params.getDefaultKeyCoordX());
1804    }
1805
1806    //     [7]     ___|
1807    // [6] [4] [5] ___|
1808    // [3] <1> [2] ___|
1809    public void testLayout7KeyMax3R2() {
1810        MoreKeysKeyboardParams params = createParams(7, 3, XPOS_R2);
1811        assertEquals("7 key max 3 R2 columns", 3, params.mNumColumns);
1812        assertEquals("7 key max 3 R2 rows", 3, params.mNumRows);
1813        assertEquals("7 key max 3 R2 left", 1, params.mLeftKeys);
1814        assertEquals("7 key max 3 R2 right", 2, params.mRightKeys);
1815        assertEquals("7 key max 3 R2 <1>", 0, params.getColumnPos(0));
1816        assertEquals("7 key max 3 R2 [2]", 1, params.getColumnPos(1));
1817        assertEquals("7 key max 3 R2 [3]", -1, params.getColumnPos(2));
1818        assertEquals("7 key max 3 R2 [4]", 0, params.getColumnPos(3));
1819        assertEquals("7 key max 3 R2 [5]", 1, params.getColumnPos(4));
1820        assertEquals("7 key max 3 R2 [6]", -1, params.getColumnPos(5));
1821        assertEquals("7 key max 3 R2 [7]", 0, params.getColumnPos(6));
1822        assertEquals("7 key max 3 R2 adjust", 0, params.mTopRowAdjustment);
1823        assertEquals("7 key max 3 R2 default", WIDTH * 1, params.getDefaultKeyCoordX());
1824    }
1825
1826    // [7] [5] [6] [8]
1827    // [3] <1> [2] [4]
1828    public void testLayout8KeyMax5M0() {
1829        MoreKeysKeyboardParams params = createParams(8, 5, XPOS_M0);
1830        assertEquals("8 key max 5 M0 columns", 4, params.mNumColumns);
1831        assertEquals("8 key max 5 M0 rows", 2, params.mNumRows);
1832        assertEquals("8 key max 5 M0 left", 1, params.mLeftKeys);
1833        assertEquals("8 key max 5 M0 right", 3, params.mRightKeys);
1834        assertEquals("8 key max 5 M0 <1>", 0, params.getColumnPos(0));
1835        assertEquals("8 key max 5 M0 [2]", 1, params.getColumnPos(1));
1836        assertEquals("8 key max 5 M0 [3]", -1, params.getColumnPos(2));
1837        assertEquals("8 key max 5 M0 [4]", 2, params.getColumnPos(3));
1838        assertEquals("8 key max 5 M0 [5]", 0, params.getColumnPos(4));
1839        assertEquals("8 key max 5 M0 [6]", 1, params.getColumnPos(5));
1840        assertEquals("8 key max 5 M0 [7]", -1, params.getColumnPos(6));
1841        assertEquals("8 key max 5 M0 [8]", 2, params.getColumnPos(7));
1842        assertEquals("8 key max 5 M0 adjust", 0, params.mTopRowAdjustment);
1843        assertEquals("8 key max 5 M0 default", WIDTH * 1, params.getDefaultKeyCoordX());
1844    }
1845
1846    // |[5] [6] [7] [8]
1847    // |<1> [2] [3] [4]
1848    public void testLayout8KeyMax5L0() {
1849        MoreKeysKeyboardParams params = createParams(8, 5, XPOS_L0);
1850        assertEquals("8 key max 5 L0 columns", 4, params.mNumColumns);
1851        assertEquals("8 key max 5 L0 rows", 2, params.mNumRows);
1852        assertEquals("8 key max 5 L0 left", 0, params.mLeftKeys);
1853        assertEquals("8 key max 5 L0 right", 4, params.mRightKeys);
1854        assertEquals("8 key max 5 L0 <1>", 0, params.getColumnPos(0));
1855        assertEquals("8 key max 5 L0 [2]", 1, params.getColumnPos(1));
1856        assertEquals("8 key max 5 L0 [3]", 2, params.getColumnPos(2));
1857        assertEquals("8 key max 5 L0 [4]", 3, params.getColumnPos(3));
1858        assertEquals("8 key max 5 L0 [5]", 0, params.getColumnPos(4));
1859        assertEquals("8 key max 5 L0 [6]", 1, params.getColumnPos(5));
1860        assertEquals("8 key max 5 L0 [7]", 2, params.getColumnPos(6));
1861        assertEquals("8 key max 5 L0 [8]", 3, params.getColumnPos(7));
1862        assertEquals("8 key max 5 L0 adjust", 0, params.mTopRowAdjustment);
1863        assertEquals("8 key max 5 L0 default", WIDTH * 0, params.getDefaultKeyCoordX());
1864    }
1865
1866    // |___ [5] [6] [7] [8]
1867    // |___ <1> [2] [3] [4]
1868    public void testLayout8KeyMax5L1() {
1869        MoreKeysKeyboardParams params = createParams(8, 5, XPOS_L1);
1870        assertEquals("8 key max 5 L1 columns", 4, params.mNumColumns);
1871        assertEquals("8 key max 5 L1 rows", 2, params.mNumRows);
1872        assertEquals("8 key max 5 L1 left", 0, params.mLeftKeys);
1873        assertEquals("8 key max 5 L1 right", 4, params.mRightKeys);
1874        assertEquals("8 key max 5 L1 <1>", 0, params.getColumnPos(0));
1875        assertEquals("8 key max 5 L1 [2]", 1, params.getColumnPos(1));
1876        assertEquals("8 key max 5 L1 [3]", 2, params.getColumnPos(2));
1877        assertEquals("8 key max 5 L1 [4]", 3, params.getColumnPos(3));
1878        assertEquals("8 key max 5 L1 [5]", 0, params.getColumnPos(4));
1879        assertEquals("8 key max 5 L1 [6]", 1, params.getColumnPos(5));
1880        assertEquals("8 key max 5 L1 [7]", 2, params.getColumnPos(6));
1881        assertEquals("8 key max 5 L1 [8]", 3, params.getColumnPos(7));
1882        assertEquals("8 key max 5 L1 adjust", 0, params.mTopRowAdjustment);
1883        assertEquals("8 key max 5 L1 default", WIDTH * 0, params.getDefaultKeyCoordX());
1884    }
1885
1886    // |___ [7] [5] [6] [8]
1887    // |___ [3] <1> [2] [4]
1888    public void testLayout8KeyMax5L2() {
1889        MoreKeysKeyboardParams params = createParams(8, 5, XPOS_L2);
1890        assertEquals("8 key max 5 L2 columns", 4, params.mNumColumns);
1891        assertEquals("8 key max 5 L2 rows", 2, params.mNumRows);
1892        assertEquals("8 key max 5 L2 left", 1, params.mLeftKeys);
1893        assertEquals("8 key max 5 L2 right", 3, params.mRightKeys);
1894        assertEquals("8 key max 5 L2 <1>", 0, params.getColumnPos(0));
1895        assertEquals("8 key max 5 L2 [2]", 1, params.getColumnPos(1));
1896        assertEquals("8 key max 5 L2 [3]", -1, params.getColumnPos(2));
1897        assertEquals("8 key max 5 L2 [4]", 2, params.getColumnPos(3));
1898        assertEquals("8 key max 5 L2 [5]", 0, params.getColumnPos(4));
1899        assertEquals("8 key max 5 L2 [6]", 1, params.getColumnPos(5));
1900        assertEquals("8 key max 5 L2 [7]", -1, params.getColumnPos(6));
1901        assertEquals("8 key max 5 L2 [8]", 2, params.getColumnPos(7));
1902        assertEquals("8 key max 5 L2 adjust", 0, params.mTopRowAdjustment);
1903        assertEquals("8 key max 5 L2 default", WIDTH * 1, params.getDefaultKeyCoordX());
1904    }
1905
1906    // [8] [7] [6] [5]|
1907    // [4] [3] [2] <1>|
1908    public void testLayout8KeyMax5R0() {
1909        MoreKeysKeyboardParams params = createParams(8, 5, XPOS_R0);
1910        assertEquals("8 key max 5 R0 columns", 4, params.mNumColumns);
1911        assertEquals("8 key max 5 R0 rows", 2, params.mNumRows);
1912        assertEquals("8 key max 5 R0 left", 3, params.mLeftKeys);
1913        assertEquals("8 key max 5 R0 right", 1, params.mRightKeys);
1914        assertEquals("8 key max 5 R0 <1>", 0, params.getColumnPos(0));
1915        assertEquals("8 key max 5 R0 [2]", -1, params.getColumnPos(1));
1916        assertEquals("8 key max 5 R0 [3]", -2, params.getColumnPos(2));
1917        assertEquals("8 key max 5 R0 [4]", -3, params.getColumnPos(3));
1918        assertEquals("8 key max 5 R0 [5]", 0, params.getColumnPos(4));
1919        assertEquals("8 key max 5 R0 [6]", -1, params.getColumnPos(5));
1920        assertEquals("8 key max 5 R0 [7]", -2, params.getColumnPos(6));
1921        assertEquals("8 key max 5 R0 [8]", -3, params.getColumnPos(7));
1922        assertEquals("8 key max 5 R0 adjust", 0, params.mTopRowAdjustment);
1923        assertEquals("8 key max 5 R0 default", WIDTH * 3, params.getDefaultKeyCoordX());
1924    }
1925
1926    // [8] [7] [6] [5] ___|
1927    // [4] [3] [2] <1> ___|
1928    public void testLayout8KeyMax5R1() {
1929        MoreKeysKeyboardParams params = createParams(8, 5, XPOS_R1);
1930        assertEquals("8 key max 5 R1 columns", 4, params.mNumColumns);
1931        assertEquals("8 key max 5 R1 rows", 2, params.mNumRows);
1932        assertEquals("8 key max 5 R1 left", 3, params.mLeftKeys);
1933        assertEquals("8 key max 5 R1 right", 1, params.mRightKeys);
1934        assertEquals("8 key max 5 R1 <1>", 0, params.getColumnPos(0));
1935        assertEquals("8 key max 5 R1 [2]", -1, params.getColumnPos(1));
1936        assertEquals("8 key max 5 R1 [3]", -2, params.getColumnPos(2));
1937        assertEquals("8 key max 5 R1 [4]", -3, params.getColumnPos(3));
1938        assertEquals("8 key max 5 R1 [5]", 0, params.getColumnPos(4));
1939        assertEquals("8 key max 5 R1 [6]", -1, params.getColumnPos(5));
1940        assertEquals("8 key max 5 R1 [7]", -2, params.getColumnPos(6));
1941        assertEquals("8 key max 5 R1 [8]", -3, params.getColumnPos(7));
1942        assertEquals("8 key max 5 R1 adjust", 0, params.mTopRowAdjustment);
1943        assertEquals("8 key max 5 R1 default", WIDTH * 3, params.getDefaultKeyCoordX());
1944    }
1945
1946    // [8] [7] [5] [6] ___|
1947    // [4] [3] <1> [2] ___|
1948    public void testLayout8KeyMax5R2() {
1949        MoreKeysKeyboardParams params = createParams(8, 5, XPOS_R2);
1950        assertEquals("8 key max 5 R2 columns", 4, params.mNumColumns);
1951        assertEquals("8 key max 5 R2 rows", 2, params.mNumRows);
1952        assertEquals("8 key max 5 R2 left", 2, params.mLeftKeys);
1953        assertEquals("8 key max 5 R2 right", 2, params.mRightKeys);
1954        assertEquals("8 key max 5 R2 <1>", 0, params.getColumnPos(0));
1955        assertEquals("8 key max 5 R2 [2]", 1, params.getColumnPos(1));
1956        assertEquals("8 key max 5 R2 [3]", -1, params.getColumnPos(2));
1957        assertEquals("8 key max 5 R2 [4]", -2, params.getColumnPos(3));
1958        assertEquals("8 key max 5 R2 [5]", 0, params.getColumnPos(4));
1959        assertEquals("8 key max 5 R2 [6]", 1, params.getColumnPos(5));
1960        assertEquals("8 key max 5 R2 [7]", -1, params.getColumnPos(6));
1961        assertEquals("8 key max 5 R2 [8]", -2, params.getColumnPos(7));
1962        assertEquals("8 key max 5 R2 adjust", 0, params.mTopRowAdjustment);
1963        assertEquals("8 key max 5 R2 default", WIDTH * 2, params.getDefaultKeyCoordX());
1964    }
1965
1966    //   [8] [6] [7] [9]
1967    // [5] [3] <1> [2] [4]
1968    public void testLayout9KeyMax5M0() {
1969        MoreKeysKeyboardParams params = createParams(9, 5, XPOS_M0);
1970        assertEquals("9 key max 5 M0 columns", 5, params.mNumColumns);
1971        assertEquals("9 key max 5 M0 rows", 2, params.mNumRows);
1972        assertEquals("9 key max 5 M0 left", 2, params.mLeftKeys);
1973        assertEquals("9 key max 5 M0 right", 3, params.mRightKeys);
1974        assertEquals("9 key max 5 M0 <1>", 0, params.getColumnPos(0));
1975        assertEquals("9 key max 5 M0 [2]", 1, params.getColumnPos(1));
1976        assertEquals("9 key max 5 M0 [3]", -1, params.getColumnPos(2));
1977        assertEquals("9 key max 5 M0 [4]", 2, params.getColumnPos(3));
1978        assertEquals("9 key max 5 M0 [5]", -2, params.getColumnPos(4));
1979        assertEquals("9 key max 5 M0 [6]", 0, params.getColumnPos(5));
1980        assertEquals("9 key max 5 M0 [7]", 1, params.getColumnPos(6));
1981        assertEquals("9 key max 5 M0 [8]", -1, params.getColumnPos(7));
1982        assertEquals("9 key max 5 M0 [9]", 2, params.getColumnPos(8));
1983        assertEquals("9 key max 5 M0 adjust", -1, params.mTopRowAdjustment);
1984        assertEquals("9 key max 5 M0 default", WIDTH * 2, params.getDefaultKeyCoordX());
1985    }
1986
1987    // |[6] [7] [8] [9]
1988    // |<1> [2] [3] [4] [5]
1989    public void testLayout9KeyMax5L0() {
1990        MoreKeysKeyboardParams params = createParams(9, 5, XPOS_L0);
1991        assertEquals("9 key max 5 L0 columns", 5, params.mNumColumns);
1992        assertEquals("9 key max 5 L0 rows", 2, params.mNumRows);
1993        assertEquals("9 key max 5 L0 left", 0, params.mLeftKeys);
1994        assertEquals("9 key max 5 L0 right", 5, params.mRightKeys);
1995        assertEquals("9 key max 5 L0 <1>", 0, params.getColumnPos(0));
1996        assertEquals("9 key max 5 L0 [2]", 1, params.getColumnPos(1));
1997        assertEquals("9 key max 5 L0 [3]", 2, params.getColumnPos(2));
1998        assertEquals("9 key max 5 L0 [4]", 3, params.getColumnPos(3));
1999        assertEquals("9 key max 5 L0 [5]", 4, params.getColumnPos(4));
2000        assertEquals("9 key max 5 L0 [6]", 0, params.getColumnPos(5));
2001        assertEquals("9 key max 5 L0 [7]", 1, params.getColumnPos(6));
2002        assertEquals("9 key max 5 L0 [8]", 2, params.getColumnPos(7));
2003        assertEquals("9 key max 5 L0 [9]", 3, params.getColumnPos(8));
2004        assertEquals("9 key max 5 L0 adjust", 0, params.mTopRowAdjustment);
2005        assertEquals("9 key max 5 L0 default", WIDTH * 0, params.getDefaultKeyCoordX());
2006    }
2007
2008    // |___ [6] [7] [8] [9]
2009    // |___ <1> [2] [3] [4] [5]
2010    public void testLayout9KeyMax5L1() {
2011        MoreKeysKeyboardParams params = createParams(9, 5, XPOS_L1);
2012        assertEquals("9 key max 5 L1 columns", 5, params.mNumColumns);
2013        assertEquals("9 key max 5 L1 rows", 2, params.mNumRows);
2014        assertEquals("9 key max 5 L1 left", 0, params.mLeftKeys);
2015        assertEquals("9 key max 5 L1 right", 5, params.mRightKeys);
2016        assertEquals("9 key max 5 L1 <1>", 0, params.getColumnPos(0));
2017        assertEquals("9 key max 5 L1 [2]", 1, params.getColumnPos(1));
2018        assertEquals("9 key max 5 L1 [3]", 2, params.getColumnPos(2));
2019        assertEquals("9 key max 5 L1 [4]", 3, params.getColumnPos(3));
2020        assertEquals("9 key max 5 L1 [5]", 4, params.getColumnPos(4));
2021        assertEquals("9 key max 5 L1 [6]", 0, params.getColumnPos(5));
2022        assertEquals("9 key max 5 L1 [7]", 1, params.getColumnPos(6));
2023        assertEquals("9 key max 5 L1 [8]", 2, params.getColumnPos(7));
2024        assertEquals("9 key max 5 L1 [9]", 3, params.getColumnPos(8));
2025        assertEquals("9 key max 5 L1 adjust",0, params.mTopRowAdjustment);
2026        assertEquals("9 key max 5 L1 default", WIDTH * 0, params.getDefaultKeyCoordX());
2027    }
2028
2029    // |___   [6] [7] [8] [9]
2030    // |___ [3] <1> [2] [4] [5]
2031    public void testLayout9KeyMax5L2() {
2032        MoreKeysKeyboardParams params = createParams(9, 5, XPOS_L2);
2033        assertEquals("9 key max 5 L2 columns", 5, params.mNumColumns);
2034        assertEquals("9 key max 5 L2 rows", 2, params.mNumRows);
2035        assertEquals("9 key max 5 L2 left", 1, params.mLeftKeys);
2036        assertEquals("9 key max 5 L2 right", 4, params.mRightKeys);
2037        assertEquals("9 key max 5 L2 <1>", 0, params.getColumnPos(0));
2038        assertEquals("9 key max 5 L2 [2]", 1, params.getColumnPos(1));
2039        assertEquals("9 key max 5 L2 [3]", -1, params.getColumnPos(2));
2040        assertEquals("9 key max 5 L2 [4]", 2, params.getColumnPos(3));
2041        assertEquals("9 key max 5 L2 [5]", 3, params.getColumnPos(4));
2042        assertEquals("9 key max 5 L2 [6]", 0, params.getColumnPos(5));
2043        assertEquals("9 key max 5 L2 [7]", 1, params.getColumnPos(6));
2044        assertEquals("9 key max 5 L2 [8]", 2, params.getColumnPos(7));
2045        assertEquals("9 key max 5 L2 [9]", 3, params.getColumnPos(8));
2046        assertEquals("9 key max 5 L2 adjust", -1, params.mTopRowAdjustment);
2047        assertEquals("9 key max 5 L2 default", WIDTH * 1, params.getDefaultKeyCoordX());
2048    }
2049
2050    //     [9] [8] [7] [6]|
2051    // [5] [4] [3] [2] <1>|
2052    public void testLayout9KeyMax5R0() {
2053        MoreKeysKeyboardParams params = createParams(9, 5, XPOS_R0);
2054        assertEquals("9 key max 5 R0 columns", 5, params.mNumColumns);
2055        assertEquals("9 key max 5 R0 rows", 2, params.mNumRows);
2056        assertEquals("9 key max 5 R0 left", 4, params.mLeftKeys);
2057        assertEquals("9 key max 5 R0 right", 1, params.mRightKeys);
2058        assertEquals("9 key max 5 R0 <1>", 0, params.getColumnPos(0));
2059        assertEquals("9 key max 5 R0 [2]", -1, params.getColumnPos(1));
2060        assertEquals("9 key max 5 R0 [3]", -2, params.getColumnPos(2));
2061        assertEquals("9 key max 5 R0 [4]", -3, params.getColumnPos(3));
2062        assertEquals("9 key max 5 R0 [5]", -4, params.getColumnPos(4));
2063        assertEquals("9 key max 5 R0 [6]", 0, params.getColumnPos(5));
2064        assertEquals("9 key max 5 R0 [7]", -1, params.getColumnPos(6));
2065        assertEquals("9 key max 5 R0 [8]", -2, params.getColumnPos(7));
2066        assertEquals("9 key max 5 R0 [9]", -3, params.getColumnPos(8));
2067        assertEquals("9 key max 5 R0 adjust", 0, params.mTopRowAdjustment);
2068        assertEquals("9 key max 5 R0 default", WIDTH * 4, params.getDefaultKeyCoordX());
2069    }
2070
2071    //     [9] [8] [7] [6] ___|
2072    // [5] [4] [3] [2] <1> ___|
2073    public void testLayout9KeyMax5R1() {
2074        MoreKeysKeyboardParams params = createParams(9, 5, XPOS_R1);
2075        assertEquals("9 key max 5 R1 columns", 5, params.mNumColumns);
2076        assertEquals("9 key max 5 R1 rows", 2, params.mNumRows);
2077        assertEquals("9 key max 5 R1 left", 4, params.mLeftKeys);
2078        assertEquals("9 key max 5 R1 right", 1, params.mRightKeys);
2079        assertEquals("9 key max 5 R1 <1>", 0, params.getColumnPos(0));
2080        assertEquals("9 key max 5 R1 [2]", -1, params.getColumnPos(1));
2081        assertEquals("9 key max 5 R1 [3]", -2, params.getColumnPos(2));
2082        assertEquals("9 key max 5 R1 [4]", -3, params.getColumnPos(3));
2083        assertEquals("9 key max 5 R1 [5]", -4, params.getColumnPos(4));
2084        assertEquals("9 key max 5 R1 [6]", 0, params.getColumnPos(5));
2085        assertEquals("9 key max 5 R1 [7]", -1, params.getColumnPos(6));
2086        assertEquals("9 key max 5 R1 [8]", -2, params.getColumnPos(7));
2087        assertEquals("9 key max 5 R1 [9]", -3, params.getColumnPos(8));
2088        assertEquals("9 key max 5 R1 adjust", 0, params.mTopRowAdjustment);
2089        assertEquals("9 key max 5 R1 default", WIDTH * 4, params.getDefaultKeyCoordX());
2090    }
2091
2092    //   [9] [8] [6] [7]   ___|
2093    // [5] [4] [3] <1> [2] ___|
2094    public void testLayout9KeyMax5R2() {
2095        MoreKeysKeyboardParams params = createParams(9, 5, XPOS_R2);
2096        assertEquals("9 key max 5 R2 columns", 5, params.mNumColumns);
2097        assertEquals("9 key max 5 R2 rows", 2, params.mNumRows);
2098        assertEquals("9 key max 5 R2 left", 3, params.mLeftKeys);
2099        assertEquals("9 key max 5 R2 right", 2, params.mRightKeys);
2100        assertEquals("9 key max 5 R2 <1>", 0, params.getColumnPos(0));
2101        assertEquals("9 key max 5 R2 [2]", 1, params.getColumnPos(1));
2102        assertEquals("9 key max 5 R2 [3]", -1, params.getColumnPos(2));
2103        assertEquals("9 key max 5 R2 [4]", -2, params.getColumnPos(3));
2104        assertEquals("9 key max 5 R2 [5]", -3, params.getColumnPos(4));
2105        assertEquals("9 key max 5 R2 [6]", 0, params.getColumnPos(5));
2106        assertEquals("9 key max 5 R2 [7]", 1, params.getColumnPos(6));
2107        assertEquals("9 key max 5 R2 [8]", -1, params.getColumnPos(7));
2108        assertEquals("9 key max 5 R2 [9]", -2, params.getColumnPos(8));
2109        assertEquals("9 key max 5 R2 adjust", -1, params.mTopRowAdjustment);
2110        assertEquals("9 key max 5 R2 default", WIDTH * 3, params.getDefaultKeyCoordX());
2111    }
2112
2113    // [A] [8] [6] [7] [9]
2114    // [5] [3] <1> [2] [4]
2115    public void testLayout10KeyMax5M0() {
2116        MoreKeysKeyboardParams params = createParams(10, 5, XPOS_M0);
2117        assertEquals("10 key max 5 M0 columns", 5, params.mNumColumns);
2118        assertEquals("10 key max 5 M0 rows", 2, params.mNumRows);
2119        assertEquals("10 key max 5 M0 left", 2, params.mLeftKeys);
2120        assertEquals("10 key max 5 M0 right", 3, params.mRightKeys);
2121        assertEquals("10 key max 5 M0 <1>", 0, params.getColumnPos(0));
2122        assertEquals("10 key max 5 M0 [2]", 1, params.getColumnPos(1));
2123        assertEquals("10 key max 5 M0 [3]", -1, params.getColumnPos(2));
2124        assertEquals("10 key max 5 M0 [4]", 2, params.getColumnPos(3));
2125        assertEquals("10 key max 5 M0 [5]", -2, params.getColumnPos(4));
2126        assertEquals("10 key max 5 M0 [6]", 0, params.getColumnPos(5));
2127        assertEquals("10 key max 5 M0 [7]", 1, params.getColumnPos(6));
2128        assertEquals("10 key max 5 M0 [8]", -1, params.getColumnPos(7));
2129        assertEquals("10 key max 5 M0 [9]", 2, params.getColumnPos(8));
2130        assertEquals("10 key max 5 M0 [A]", -2, params.getColumnPos(9));
2131        assertEquals("10 key max 5 M0 adjust", 0, params.mTopRowAdjustment);
2132        assertEquals("10 key max 5 M0 default", WIDTH * 2, params.getDefaultKeyCoordX());
2133    }
2134
2135    // |[6] [7] [8] [9] [A]
2136    // |<1> [2] [3] [4] [5]
2137    public void testLayout10KeyMax5L0() {
2138        MoreKeysKeyboardParams params = createParams(10, 5, XPOS_L0);
2139        assertEquals("10 key max 5 L0 columns", 5, params.mNumColumns);
2140        assertEquals("10 key max 5 L0 rows", 2, params.mNumRows);
2141        assertEquals("10 key max 5 L0 left", 0, params.mLeftKeys);
2142        assertEquals("10 key max 5 L0 right", 5, params.mRightKeys);
2143        assertEquals("10 key max 5 L0 <1>", 0, params.getColumnPos(0));
2144        assertEquals("10 key max 5 L0 [2]", 1, params.getColumnPos(1));
2145        assertEquals("10 key max 5 L0 [3]", 2, params.getColumnPos(2));
2146        assertEquals("10 key max 5 L0 [4]", 3, params.getColumnPos(3));
2147        assertEquals("10 key max 5 L0 [5]", 4, params.getColumnPos(4));
2148        assertEquals("10 key max 5 L0 [6]", 0, params.getColumnPos(5));
2149        assertEquals("10 key max 5 L0 [7]", 1, params.getColumnPos(6));
2150        assertEquals("10 key max 5 L0 [8]", 2, params.getColumnPos(7));
2151        assertEquals("10 key max 5 L0 [9]", 3, params.getColumnPos(8));
2152        assertEquals("10 key max 5 L0 [A]", 4, params.getColumnPos(9));
2153        assertEquals("10 key max 5 L0 adjust", 0, params.mTopRowAdjustment);
2154        assertEquals("10 key max 5 L0 default", WIDTH * 0, params.getDefaultKeyCoordX());
2155    }
2156
2157    // |___ [6] [7] [8] [9] [A]
2158    // |___ <1> [2] [3] [4] [5]
2159    public void testLayout10KeyMax5L1() {
2160        MoreKeysKeyboardParams params = createParams(10, 5, XPOS_L1);
2161        assertEquals("10 key max 5 L1 columns", 5, params.mNumColumns);
2162        assertEquals("10 key max 5 L1 rows", 2, params.mNumRows);
2163        assertEquals("10 key max 5 L1 left", 0, params.mLeftKeys);
2164        assertEquals("10 key max 5 L1 right", 5, params.mRightKeys);
2165        assertEquals("10 key max 5 L1 <1>", 0, params.getColumnPos(0));
2166        assertEquals("10 key max 5 L1 [2]", 1, params.getColumnPos(1));
2167        assertEquals("10 key max 5 L1 [3]", 2, params.getColumnPos(2));
2168        assertEquals("10 key max 5 L1 [4]", 3, params.getColumnPos(3));
2169        assertEquals("10 key max 5 L1 [5]", 4, params.getColumnPos(4));
2170        assertEquals("10 key max 5 L1 [6]", 0, params.getColumnPos(5));
2171        assertEquals("10 key max 5 L1 [7]", 1, params.getColumnPos(6));
2172        assertEquals("10 key max 5 L1 [8]", 2, params.getColumnPos(7));
2173        assertEquals("10 key max 5 L1 [9]", 3, params.getColumnPos(8));
2174        assertEquals("10 key max 5 L1 [A]", 4, params.getColumnPos(9));
2175        assertEquals("10 key max 5 L1 adjust", 0, params.mTopRowAdjustment);
2176        assertEquals("10 key max 5 L1 default", WIDTH * 0, params.getDefaultKeyCoordX());
2177    }
2178
2179    // |___ [8] [6] [7] [9] [A]
2180    // |___ [3] <1> [2] [4] [5]
2181    public void testLayout10KeyMax5L2() {
2182        MoreKeysKeyboardParams params = createParams(10, 5, XPOS_L2);
2183        assertEquals("10 key max 5 L2 columns", 5, params.mNumColumns);
2184        assertEquals("10 key max 5 L2 rows", 2, params.mNumRows);
2185        assertEquals("10 key max 5 L2 left", 1, params.mLeftKeys);
2186        assertEquals("10 key max 5 L2 right", 4, params.mRightKeys);
2187        assertEquals("10 key max 5 L2 <1>", 0, params.getColumnPos(0));
2188        assertEquals("10 key max 5 L2 [2]", 1, params.getColumnPos(1));
2189        assertEquals("10 key max 5 L2 [3]", -1, params.getColumnPos(2));
2190        assertEquals("10 key max 5 L2 [4]", 2, params.getColumnPos(3));
2191        assertEquals("10 key max 5 L2 [5]", 3, params.getColumnPos(4));
2192        assertEquals("10 key max 5 L2 [6]", 0, params.getColumnPos(5));
2193        assertEquals("10 key max 5 L2 [7]", 1, params.getColumnPos(6));
2194        assertEquals("10 key max 5 L2 [8]", -1, params.getColumnPos(7));
2195        assertEquals("10 key max 5 L2 [9]", 2, params.getColumnPos(8));
2196        assertEquals("10 key max 5 L2 [A]", 3, params.getColumnPos(9));
2197        assertEquals("10 key max 5 L2 adjust", 0, params.mTopRowAdjustment);
2198        assertEquals("10 key max 5 L2 default", WIDTH * 1, params.getDefaultKeyCoordX());
2199    }
2200
2201    // [A] [9] [8] [7] [6]|
2202    // [5] [4] [3] [2] <1>|
2203    public void testLayout10KeyMax5R0() {
2204        MoreKeysKeyboardParams params = createParams(10, 5, XPOS_R0);
2205        assertEquals("10 key max 5 R0 columns", 5, params.mNumColumns);
2206        assertEquals("10 key max 5 R0 rows", 2, params.mNumRows);
2207        assertEquals("10 key max 5 R0 left", 4, params.mLeftKeys);
2208        assertEquals("10 key max 5 R0 right", 1, params.mRightKeys);
2209        assertEquals("10 key max 5 R0 <1>", 0, params.getColumnPos(0));
2210        assertEquals("10 key max 5 R0 [2]", -1, params.getColumnPos(1));
2211        assertEquals("10 key max 5 R0 [3]", -2, params.getColumnPos(2));
2212        assertEquals("10 key max 5 R0 [4]", -3, params.getColumnPos(3));
2213        assertEquals("10 key max 5 R0 [5]", -4, params.getColumnPos(4));
2214        assertEquals("10 key max 5 R0 [6]", 0, params.getColumnPos(5));
2215        assertEquals("10 key max 5 R0 [7]", -1, params.getColumnPos(6));
2216        assertEquals("10 key max 5 R0 [8]", -2, params.getColumnPos(7));
2217        assertEquals("10 key max 5 R0 [9]", -3, params.getColumnPos(8));
2218        assertEquals("10 key max 5 R0 [A]", -4, params.getColumnPos(9));
2219        assertEquals("10 key max 5 R0 adjust", 0, params.mTopRowAdjustment);
2220        assertEquals("10 key max 5 R0 default", WIDTH * 4, params.getDefaultKeyCoordX());
2221    }
2222
2223    // [A] [9] [8] [7] [6] ___|
2224    // [5] [4] [3] [2] <1> ___|
2225    public void testLayout10KeyMax5R1() {
2226        MoreKeysKeyboardParams params = createParams(10, 5, XPOS_R1);
2227        assertEquals("10 key max 5 R1 columns", 5, params.mNumColumns);
2228        assertEquals("10 key max 5 R1 rows", 2, params.mNumRows);
2229        assertEquals("10 key max 5 R1 left", 4, params.mLeftKeys);
2230        assertEquals("10 key max 5 R1 right", 1, params.mRightKeys);
2231        assertEquals("10 key max 5 R1 <1>", 0, params.getColumnPos(0));
2232        assertEquals("10 key max 5 R1 [2]", -1, params.getColumnPos(1));
2233        assertEquals("10 key max 5 R1 [3]", -2, params.getColumnPos(2));
2234        assertEquals("10 key max 5 R1 [4]", -3, params.getColumnPos(3));
2235        assertEquals("10 key max 5 R1 [5]", -4, params.getColumnPos(4));
2236        assertEquals("10 key max 5 R1 [6]", 0, params.getColumnPos(5));
2237        assertEquals("10 key max 5 R1 [7]", -1, params.getColumnPos(6));
2238        assertEquals("10 key max 5 R1 [8]", -2, params.getColumnPos(7));
2239        assertEquals("10 key max 5 R1 [9]", -3, params.getColumnPos(8));
2240        assertEquals("10 key max 5 R1 [A]", -4, params.getColumnPos(9));
2241        assertEquals("10 key max 5 R1 adjust", 0, params.mTopRowAdjustment);
2242        assertEquals("10 key max 5 R1 default", WIDTH * 4, params.getDefaultKeyCoordX());
2243    }
2244
2245    // [A] [9] [8] [6] [7] ___|
2246    // [5] [4] [3] <1> [2] ___|
2247    public void testLayout10KeyMax5R2() {
2248        MoreKeysKeyboardParams params = createParams(10, 5, XPOS_R2);
2249        assertEquals("10 key max 5 R2 columns", 5, params.mNumColumns);
2250        assertEquals("10 key max 5 R2 rows", 2, params.mNumRows);
2251        assertEquals("10 key max 5 R2 left", 3, params.mLeftKeys);
2252        assertEquals("10 key max 5 R2 right", 2, params.mRightKeys);
2253        assertEquals("10 key max 5 R2 <1>", 0, params.getColumnPos(0));
2254        assertEquals("10 key max 5 R2 [2]", 1, params.getColumnPos(1));
2255        assertEquals("10 key max 5 R2 [3]", -1, params.getColumnPos(2));
2256        assertEquals("10 key max 5 R2 [4]", -2, params.getColumnPos(3));
2257        assertEquals("10 key max 5 R2 [5]", -3, params.getColumnPos(4));
2258        assertEquals("10 key max 5 R2 [6]", 0, params.getColumnPos(5));
2259        assertEquals("10 key max 5 R2 [7]", 1, params.getColumnPos(6));
2260        assertEquals("10 key max 5 R2 [8]", -1, params.getColumnPos(7));
2261        assertEquals("10 key max 5 R2 [9]", -2, params.getColumnPos(8));
2262        assertEquals("10 key max 5 R2 [A]", -3, params.getColumnPos(9));
2263        assertEquals("10 key max 5 R2 adjust", 0, params.mTopRowAdjustment);
2264        assertEquals("10 key max 5 R2 default", WIDTH * 3, params.getDefaultKeyCoordX());
2265    }
2266
2267    //   [9] [A] [B]
2268    // [7] [5] [6] [8]
2269    // [3] <1> [2] [4]
2270    public void testLayout11KeyMax5M0() {
2271        MoreKeysKeyboardParams params = createParams(11, 5, XPOS_M0);
2272        assertEquals("11 key max 5 M0 columns", 4, params.mNumColumns);
2273        assertEquals("11 key max 5 M0 rows", 3, params.mNumRows);
2274        assertEquals("11 key max 5 M0 left", 1, params.mLeftKeys);
2275        assertEquals("11 key max 5 M0 right", 3, params.mRightKeys);
2276        assertEquals("11 key max 5 M0 <1>", 0, params.getColumnPos(0));
2277        assertEquals("11 key max 5 M0 [2]", 1, params.getColumnPos(1));
2278        assertEquals("11 key max 5 M0 [3]", -1, params.getColumnPos(2));
2279        assertEquals("11 key max 5 M0 [4]", 2, params.getColumnPos(3));
2280        assertEquals("11 key max 5 M0 [5]", 0, params.getColumnPos(4));
2281        assertEquals("11 key max 5 M0 [6]", 1, params.getColumnPos(5));
2282        assertEquals("11 key max 5 M0 [7]", -1, params.getColumnPos(6));
2283        assertEquals("11 key max 5 M0 [8]", 2, params.getColumnPos(7));
2284        assertEquals("11 key max 5 M0 [9]", 0, params.getColumnPos(8));
2285        assertEquals("11 key max 5 M0 [A]", 1, params.getColumnPos(9));
2286        assertEquals("11 key max 5 M0 [B]", 2, params.getColumnPos(10));
2287        assertEquals("11 key max 5 M0 adjust", -1, params.mTopRowAdjustment);
2288        assertEquals("11 key max 5 M0 default", WIDTH * 1, params.getDefaultKeyCoordX());
2289    }
2290
2291    // [B] [9] [A] [C]
2292    // [7] [5] [6] [8]
2293    // [3] <1> [2] [4]
2294    public void testLayout12KeyMax5M0() {
2295        MoreKeysKeyboardParams params = createParams(12, 5, XPOS_M0);
2296        assertEquals("12 key max 5 M0 columns", 4, params.mNumColumns);
2297        assertEquals("12 key max 5 M0 rows", 3, params.mNumRows);
2298        assertEquals("12 key max 5 M0 left", 1, params.mLeftKeys);
2299        assertEquals("12 key max 5 M0 right", 3, params.mRightKeys);
2300        assertEquals("12 key max 5 M0 <1>", 0, params.getColumnPos(0));
2301        assertEquals("12 key max 5 M0 [2]", 1, params.getColumnPos(1));
2302        assertEquals("12 key max 5 M0 [3]", -1, params.getColumnPos(2));
2303        assertEquals("12 key max 5 M0 [4]", 2, params.getColumnPos(3));
2304        assertEquals("12 key max 5 M0 [5]", 0, params.getColumnPos(4));
2305        assertEquals("12 key max 5 M0 [6]", 1, params.getColumnPos(5));
2306        assertEquals("12 key max 5 M0 [7]", -1, params.getColumnPos(6));
2307        assertEquals("12 key max 5 M0 [8]", 2, params.getColumnPos(7));
2308        assertEquals("12 key max 5 M0 [9]", 0, params.getColumnPos(8));
2309        assertEquals("12 key max 5 M0 [A]", 1, params.getColumnPos(9));
2310        assertEquals("12 key max 5 M0 [B]", -1, params.getColumnPos(10));
2311        assertEquals("12 key max 5 M0 [C]", 2, params.getColumnPos(11));
2312        assertEquals("12 key max 5 M0 adjust", 0, params.mTopRowAdjustment);
2313        assertEquals("12 key max 5 M0 default", WIDTH * 1, params.getDefaultKeyCoordX());
2314    }
2315
2316    //     [D] [B] [C]
2317    // [A] [8] [6] [7] [9]
2318    // [5] [3] <1> [2] [4]
2319    public void testLayout13KeyMax5M0() {
2320        MoreKeysKeyboardParams params = createParams(13, 5, XPOS_M0);
2321        assertEquals("13 key max 5 M0 columns", 5, params.mNumColumns);
2322        assertEquals("13 key max 5 M0 rows", 3, params.mNumRows);
2323        assertEquals("13 key max 5 M0 left", 2, params.mLeftKeys);
2324        assertEquals("13 key max 5 M0 right", 3, params.mRightKeys);
2325        assertEquals("13 key max 5 M0 <1>", 0, params.getColumnPos(0));
2326        assertEquals("13 key max 5 M0 [2]", 1, params.getColumnPos(1));
2327        assertEquals("13 key max 5 M0 [3]", -1, params.getColumnPos(2));
2328        assertEquals("13 key max 5 M0 [4]", 2, params.getColumnPos(3));
2329        assertEquals("13 key max 5 M0 [5]", -2, params.getColumnPos(4));
2330        assertEquals("13 key max 5 M0 [6]", 0, params.getColumnPos(5));
2331        assertEquals("13 key max 5 M0 [7]", 1, params.getColumnPos(6));
2332        assertEquals("13 key max 5 M0 [8]", -1, params.getColumnPos(7));
2333        assertEquals("13 key max 5 M0 [9]", 2, params.getColumnPos(8));
2334        assertEquals("13 key max 5 M0 [A]", -2, params.getColumnPos(9));
2335        assertEquals("13 key max 5 M0 [B]", 0, params.getColumnPos(10));
2336        assertEquals("13 key max 5 M0 [C]", 1, params.getColumnPos(11));
2337        assertEquals("13 key max 5 M0 [D]", -1, params.getColumnPos(12));
2338        assertEquals("13 key max 5 M0 adjust", 0, params.mTopRowAdjustment);
2339        assertEquals("13 key max 5 M0 default", WIDTH * 2, params.getDefaultKeyCoordX());
2340    }
2341
2342    //   [D] [B] [C] [E]
2343    // [A] [8] [6] [7] [9]
2344    // [5] [3] <1> [2] [4]
2345    public void testLayout14KeyMax5M0() {
2346        MoreKeysKeyboardParams params = createParams(14, 5, XPOS_M0);
2347        assertEquals("13 key max 5 M0 columns", 5, params.mNumColumns);
2348        assertEquals("13 key max 5 M0 rows", 3, params.mNumRows);
2349        assertEquals("13 key max 5 M0 left", 2, params.mLeftKeys);
2350        assertEquals("13 key max 5 M0 right", 3, params.mRightKeys);
2351        assertEquals("13 key max 5 M0 <1>", 0, params.getColumnPos(0));
2352        assertEquals("13 key max 5 M0 [2]", 1, params.getColumnPos(1));
2353        assertEquals("13 key max 5 M0 [3]", -1, params.getColumnPos(2));
2354        assertEquals("13 key max 5 M0 [4]", 2, params.getColumnPos(3));
2355        assertEquals("13 key max 5 M0 [5]", -2, params.getColumnPos(4));
2356        assertEquals("13 key max 5 M0 [6]", 0, params.getColumnPos(5));
2357        assertEquals("13 key max 5 M0 [7]", 1, params.getColumnPos(6));
2358        assertEquals("13 key max 5 M0 [8]", -1, params.getColumnPos(7));
2359        assertEquals("13 key max 5 M0 [9]", 2, params.getColumnPos(8));
2360        assertEquals("13 key max 5 M0 [A]", -2, params.getColumnPos(9));
2361        assertEquals("13 key max 5 M0 [B]", 0, params.getColumnPos(10));
2362        assertEquals("13 key max 5 M0 [C]", 1, params.getColumnPos(11));
2363        assertEquals("13 key max 5 M0 [D]", -1, params.getColumnPos(12));
2364        assertEquals("13 key max 5 M0 [E]", 2, params.getColumnPos(13));
2365        assertEquals("13 key max 5 M0 adjust", -1, params.mTopRowAdjustment);
2366        assertEquals("13 key max 5 M0 default", WIDTH * 2, params.getDefaultKeyCoordX());
2367    }
2368}
2369