1/*
2 * Copyright (C) 2012 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.latin.common;
18
19import android.test.AndroidTestCase;
20import android.test.suitebuilder.annotation.SmallTest;
21
22import java.util.Arrays;
23
24@SmallTest
25public class InputPointersTests extends AndroidTestCase {
26    private static final int DEFAULT_CAPACITY = 48;
27
28    public void testNewInstance() {
29        final InputPointers src = new InputPointers(DEFAULT_CAPACITY);
30        assertEquals("new instance size", 0, src.getPointerSize());
31        assertNotNull("new instance xCoordinates", src.getXCoordinates());
32        assertNotNull("new instance yCoordinates", src.getYCoordinates());
33        assertNotNull("new instance pointerIds", src.getPointerIds());
34        assertNotNull("new instance times", src.getTimes());
35    }
36
37    public void testReset() {
38        final InputPointers src = new InputPointers(DEFAULT_CAPACITY);
39        final int[] xCoordinates = src.getXCoordinates();
40        final int[] yCoordinates = src.getXCoordinates();
41        final int[] pointerIds = src.getXCoordinates();
42        final int[] times = src.getXCoordinates();
43
44        src.reset();
45        assertEquals("size after reset", 0, src.getPointerSize());
46        assertNotSame("xCoordinates after reset", xCoordinates, src.getXCoordinates());
47        assertNotSame("yCoordinates after reset", yCoordinates, src.getYCoordinates());
48        assertNotSame("pointerIds after reset", pointerIds, src.getPointerIds());
49        assertNotSame("times after reset", times, src.getTimes());
50    }
51
52    public void testAdd() {
53        final InputPointers src = new InputPointers(DEFAULT_CAPACITY);
54        final int limit = src.getXCoordinates().length * 2 + 10;
55        for (int i = 0; i < limit; i++) {
56            final int x = i;
57            final int y = i * 2;
58            final int pointerId = i * 3;
59            final int time = i * 4;
60            src.addPointer(x, y, pointerId, time);
61            assertEquals("size after add " + i, i + 1, src.getPointerSize());
62        }
63        for (int i = 0; i < limit; i++) {
64            final int x = i;
65            final int y = i * 2;
66            final int pointerId = i * 3;
67            final int time = i * 4;
68            assertEquals("xCoordinates at " + i, x, src.getXCoordinates()[i]);
69            assertEquals("yCoordinates at " + i, y, src.getYCoordinates()[i]);
70            assertEquals("pointerIds at " + i, pointerId, src.getPointerIds()[i]);
71            assertEquals("times at " + i, time, src.getTimes()[i]);
72        }
73    }
74
75    public void testAddAt() {
76        final InputPointers src = new InputPointers(DEFAULT_CAPACITY);
77        final int limit = 1000, step = 100;
78        for (int i = 0; i < limit; i += step) {
79            final int x = i;
80            final int y = i * 2;
81            final int pointerId = i * 3;
82            final int time = i * 4;
83            src.addPointerAt(i, x, y, pointerId, time);
84            assertEquals("size after add at " + i, i + 1, src.getPointerSize());
85        }
86        for (int i = 0; i < limit; i += step) {
87            final int x = i;
88            final int y = i * 2;
89            final int pointerId = i * 3;
90            final int time = i * 4;
91            assertEquals("xCoordinates at " + i, x, src.getXCoordinates()[i]);
92            assertEquals("yCoordinates at " + i, y, src.getYCoordinates()[i]);
93            assertEquals("pointerIds at " + i, pointerId, src.getPointerIds()[i]);
94            assertEquals("times at " + i, time, src.getTimes()[i]);
95        }
96    }
97
98    public void testSet() {
99        final InputPointers src = new InputPointers(DEFAULT_CAPACITY);
100        final int limit = src.getXCoordinates().length * 2 + 10;
101        for (int i = 0; i < limit; i++) {
102            final int x = i;
103            final int y = i * 2;
104            final int pointerId = i * 3;
105            final int time = i * 4;
106            src.addPointer(x, y, pointerId, time);
107        }
108        final InputPointers dst = new InputPointers(DEFAULT_CAPACITY);
109        dst.set(src);
110        assertEquals("size after set", dst.getPointerSize(), src.getPointerSize());
111        assertSame("xCoordinates after set", dst.getXCoordinates(), src.getXCoordinates());
112        assertSame("yCoordinates after set", dst.getYCoordinates(), src.getYCoordinates());
113        assertSame("pointerIds after set", dst.getPointerIds(), src.getPointerIds());
114        assertSame("times after set", dst.getTimes(), src.getTimes());
115    }
116
117    public void testCopy() {
118        final InputPointers src = new InputPointers(DEFAULT_CAPACITY);
119        final int limit = 100;
120        for (int i = 0; i < limit; i++) {
121            final int x = i;
122            final int y = i * 2;
123            final int pointerId = i * 3;
124            final int time = i * 4;
125            src.addPointer(x, y, pointerId, time);
126        }
127        final InputPointers dst = new InputPointers(DEFAULT_CAPACITY);
128        dst.copy(src);
129        assertEquals("size after copy", dst.getPointerSize(), src.getPointerSize());
130        assertNotSame("xCoordinates after copy", dst.getXCoordinates(), src.getXCoordinates());
131        assertNotSame("yCoordinates after copy", dst.getYCoordinates(), src.getYCoordinates());
132        assertNotSame("pointerIds after copy", dst.getPointerIds(), src.getPointerIds());
133        assertNotSame("times after copy", dst.getTimes(), src.getTimes());
134        final int size = dst.getPointerSize();
135        assertIntArrayEquals("xCoordinates values after copy",
136                dst.getXCoordinates(), 0, src.getXCoordinates(), 0, size);
137        assertIntArrayEquals("yCoordinates values after copy",
138                dst.getYCoordinates(), 0, src.getYCoordinates(), 0, size);
139        assertIntArrayEquals("pointerIds values after copy",
140                dst.getPointerIds(), 0, src.getPointerIds(), 0, size);
141        assertIntArrayEquals("times values after copy",
142                dst.getTimes(), 0, src.getTimes(), 0, size);
143    }
144
145    public void testAppend() {
146        final int dstLength = 50;
147        final InputPointers dst = new InputPointers(DEFAULT_CAPACITY);
148        for (int i = 0; i < dstLength; i++) {
149            final int x = i * 4;
150            final int y = i * 3;
151            final int pointerId = i * 2;
152            final int time = i;
153            dst.addPointer(x, y, pointerId, time);
154        }
155        final InputPointers dstCopy = new InputPointers(DEFAULT_CAPACITY);
156        dstCopy.copy(dst);
157
158        final ResizableIntArray srcXCoords = new ResizableIntArray(DEFAULT_CAPACITY);
159        final ResizableIntArray srcYCoords = new ResizableIntArray(DEFAULT_CAPACITY);
160        final ResizableIntArray srcPointerIds = new ResizableIntArray(DEFAULT_CAPACITY);
161        final ResizableIntArray srcTimes = new ResizableIntArray(DEFAULT_CAPACITY);
162        final int srcLength = 100;
163        final int srcPointerId = 10;
164        for (int i = 0; i < srcLength; i++) {
165            final int x = i;
166            final int y = i * 2;
167            // The time value must be larger than <code>dst</code>.
168            final int time = i * 4 + dstLength;
169            srcXCoords.add(x);
170            srcYCoords.add(y);
171            srcPointerIds.add(srcPointerId);
172            srcTimes.add(time);
173        }
174
175        final int startPos = 0;
176        dst.append(srcPointerId, srcTimes, srcXCoords, srcYCoords,
177                startPos, 0 /* length */);
178        assertEquals("size after append zero", dstLength, dst.getPointerSize());
179        assertIntArrayEquals("xCoordinates after append zero",
180                dstCopy.getXCoordinates(), startPos, dst.getXCoordinates(), startPos, dstLength);
181        assertIntArrayEquals("yCoordinates after append zero",
182                dstCopy.getYCoordinates(), startPos, dst.getYCoordinates(), startPos, dstLength);
183        assertIntArrayEquals("pointerIds after append zero",
184                dstCopy.getPointerIds(), startPos, dst.getPointerIds(), startPos, dstLength);
185        assertIntArrayEquals("times after append zero",
186                dstCopy.getTimes(), startPos, dst.getTimes(), startPos, dstLength);
187
188        dst.append(srcPointerId, srcTimes, srcXCoords, srcYCoords,
189                startPos, srcLength);
190        assertEquals("size after append", dstLength + srcLength, dst.getPointerSize());
191        assertTrue("primitive length after append",
192                dst.getPointerIds().length >= dstLength + srcLength);
193        assertIntArrayEquals("original xCoordinates values after append",
194                dstCopy.getXCoordinates(), startPos, dst.getXCoordinates(), startPos, dstLength);
195        assertIntArrayEquals("original yCoordinates values after append",
196                dstCopy.getYCoordinates(), startPos, dst.getYCoordinates(), startPos, dstLength);
197        assertIntArrayEquals("original pointerIds values after append",
198                dstCopy.getPointerIds(), startPos, dst.getPointerIds(), startPos, dstLength);
199        assertIntArrayEquals("original times values after append",
200                dstCopy.getTimes(), startPos, dst.getTimes(), startPos, dstLength);
201        assertIntArrayEquals("appended xCoordinates values after append",
202                srcXCoords.getPrimitiveArray(), startPos, dst.getXCoordinates(),
203                dstLength, srcLength);
204        assertIntArrayEquals("appended yCoordinates values after append",
205                srcYCoords.getPrimitiveArray(), startPos, dst.getYCoordinates(),
206                dstLength, srcLength);
207        assertIntArrayEquals("appended pointerIds values after append",
208                srcPointerIds.getPrimitiveArray(), startPos, dst.getPointerIds(),
209                dstLength, srcLength);
210        assertIntArrayEquals("appended times values after append",
211                srcTimes.getPrimitiveArray(), startPos, dst.getTimes(), dstLength, srcLength);
212    }
213
214    public void testAppendResizableIntArray() {
215        final int dstLength = 50;
216        final InputPointers dst = new InputPointers(DEFAULT_CAPACITY);
217        for (int i = 0; i < dstLength; i++) {
218            final int x = i * 4;
219            final int y = i * 3;
220            final int pointerId = i * 2;
221            final int time = i;
222            dst.addPointer(x, y, pointerId, time);
223        }
224        final InputPointers dstCopy = new InputPointers(DEFAULT_CAPACITY);
225        dstCopy.copy(dst);
226
227        final int srcLength = 100;
228        final int srcPointerId = 1;
229        final int[] srcPointerIds = new int[srcLength];
230        Arrays.fill(srcPointerIds, srcPointerId);
231        final ResizableIntArray srcTimes = new ResizableIntArray(DEFAULT_CAPACITY);
232        final ResizableIntArray srcXCoords = new ResizableIntArray(DEFAULT_CAPACITY);
233        final ResizableIntArray srcYCoords= new ResizableIntArray(DEFAULT_CAPACITY);
234        for (int i = 0; i < srcLength; i++) {
235            // The time value must be larger than <code>dst</code>.
236            final int time = i * 2 + dstLength;
237            final int x = i * 3;
238            final int y = i * 4;
239            srcTimes.add(time);
240            srcXCoords.add(x);
241            srcYCoords.add(y);
242        }
243
244        dst.append(srcPointerId, srcTimes, srcXCoords, srcYCoords, 0, 0);
245        assertEquals("size after append zero", dstLength, dst.getPointerSize());
246        assertIntArrayEquals("xCoordinates after append zero",
247                dstCopy.getXCoordinates(), 0, dst.getXCoordinates(), 0, dstLength);
248        assertIntArrayEquals("yCoordinates after append zero",
249                dstCopy.getYCoordinates(), 0, dst.getYCoordinates(), 0, dstLength);
250        assertIntArrayEquals("pointerIds after append zero",
251                dstCopy.getPointerIds(), 0, dst.getPointerIds(), 0, dstLength);
252        assertIntArrayEquals("times after append zero",
253                dstCopy.getTimes(), 0, dst.getTimes(), 0, dstLength);
254
255        dst.append(srcPointerId, srcTimes, srcXCoords, srcYCoords, 0, srcLength);
256        assertEquals("size after append", dstLength + srcLength, dst.getPointerSize());
257        assertTrue("primitive length after append",
258                dst.getPointerIds().length >= dstLength + srcLength);
259        assertIntArrayEquals("original xCoordinates values after append",
260                dstCopy.getXCoordinates(), 0, dst.getXCoordinates(), 0, dstLength);
261        assertIntArrayEquals("original yCoordinates values after append",
262                dstCopy.getYCoordinates(), 0, dst.getYCoordinates(), 0, dstLength);
263        assertIntArrayEquals("original pointerIds values after append",
264                dstCopy.getPointerIds(), 0, dst.getPointerIds(), 0, dstLength);
265        assertIntArrayEquals("original times values after append",
266                dstCopy.getTimes(), 0, dst.getTimes(), 0, dstLength);
267        assertIntArrayEquals("appended xCoordinates values after append",
268                srcXCoords.getPrimitiveArray(), 0, dst.getXCoordinates(), dstLength, srcLength);
269        assertIntArrayEquals("appended yCoordinates values after append",
270                srcYCoords.getPrimitiveArray(), 0, dst.getYCoordinates(), dstLength, srcLength);
271        assertIntArrayEquals("appended pointerIds values after append",
272                srcPointerIds, 0, dst.getPointerIds(), dstLength, srcLength);
273        assertIntArrayEquals("appended times values after append",
274                srcTimes.getPrimitiveArray(), 0, dst.getTimes(), dstLength, srcLength);
275    }
276
277    // TODO: Consolidate this method with
278    // {@link ResizableIntArrayTests#assertIntArrayEquals(String,int[],int,int[],int,int)}.
279    private static void assertIntArrayEquals(final String message, final int[] expecteds,
280            final int expectedPos, final int[] actuals, final int actualPos, final int length) {
281        if (expecteds == actuals) {
282            return;
283        }
284        if (expecteds == null || actuals == null) {
285            assertEquals(message, Arrays.toString(expecteds), Arrays.toString(actuals));
286            return;
287        }
288        if (expecteds.length < expectedPos + length || actuals.length < actualPos + length) {
289            fail(message + ": insufficient length: expecteds=" + Arrays.toString(expecteds)
290                    + " actuals=" + Arrays.toString(actuals));
291            return;
292        }
293        for (int i = 0; i < length; i++) {
294            assertEquals(message + " [" + i + "]",
295                    expecteds[i + expectedPos], actuals[i + actualPos]);
296        }
297    }
298
299    public void testShift() {
300        final InputPointers src = new InputPointers(DEFAULT_CAPACITY);
301        final int limit = 100;
302        final int shiftAmount = 20;
303        for (int i = 0; i < limit; i++) {
304            final int x = i;
305            final int y = i * 2;
306            final int pointerId = i * 3;
307            final int time = i * 4;
308            src.addPointer(x, y, pointerId, time);
309        }
310        src.shift(shiftAmount);
311        assertEquals("length after shift", src.getPointerSize(), limit - shiftAmount);
312        for (int i = 0; i < limit - shiftAmount; ++i) {
313            final int oldIndex = i + shiftAmount;
314            final int x = oldIndex;
315            final int y = oldIndex * 2;
316            final int pointerId = oldIndex * 3;
317            final int time = oldIndex * 4;
318            assertEquals("xCoordinates at " + i, x, src.getXCoordinates()[i]);
319            assertEquals("yCoordinates at " + i, y, src.getYCoordinates()[i]);
320            assertEquals("pointerIds at " + i, pointerId, src.getPointerIds()[i]);
321            assertEquals("times at " + i, time, src.getTimes()[i]);
322        }
323    }
324}
325