xref: /packages/inputmethods/LatinIME/tests/src/com/android/inputmethod/latin/InputPointersTests.java

/*
 * Copyright (C) 2012 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */

package com.android.inputmethod.latin;

import android.test.AndroidTestCase;

import java.util.Arrays;

public class InputPointersTests extends AndroidTestCase {
    private static final int DEFAULT_CAPACITY = 48;

    public void testNewInstance() {
        final InputPointers src = new InputPointers(DEFAULT_CAPACITY);
        assertEquals("new instance size", 0, src.getPointerSize());
        assertNotNull("new instance xCoordinates", src.getXCoordinates());
        assertNotNull("new instance yCoordinates", src.getYCoordinates());
        assertNotNull("new instance pointerIds", src.getPointerIds());
        assertNotNull("new instance times", src.getTimes());
    }

    public void testReset() {
        final InputPointers src = new InputPointers(DEFAULT_CAPACITY);
        final int[] xCoordinates = src.getXCoordinates();
        final int[] yCoordinates = src.getXCoordinates();
        final int[] pointerIds = src.getXCoordinates();
        final int[] times = src.getXCoordinates();

        src.reset();
        assertEquals("size after reset", 0, src.getPointerSize());
        assertNotSame("xCoordinates after reset", xCoordinates, src.getXCoordinates());
        assertNotSame("yCoordinates after reset", yCoordinates, src.getYCoordinates());
        assertNotSame("pointerIds after reset", pointerIds, src.getPointerIds());
        assertNotSame("times after reset", times, src.getTimes());
    }

    public void testAdd() {
        final InputPointers src = new InputPointers(DEFAULT_CAPACITY);
        final int limit = src.getXCoordinates().length * 2 + 10;
        for (int i = 0; i < limit; i++) {
            src.addPointer(i, i * 2, i * 3, i * 4);
            assertEquals("size after add " + i, i + 1, src.getPointerSize());
        }
        for (int i = 0; i < limit; i++) {
            assertEquals("xCoordinates at " + i, i, src.getXCoordinates()[i]);
            assertEquals("yCoordinates at " + i, i * 2, src.getYCoordinates()[i]);
            assertEquals("pointerIds at " + i, i * 3, src.getPointerIds()[i]);
            assertEquals("times at " + i, i * 4, src.getTimes()[i]);
        }
    }

    public void testAddAt() {
        final InputPointers src = new InputPointers(DEFAULT_CAPACITY);
        final int limit = 1000, step = 100;
        for (int i = 0; i < limit; i += step) {
            src.addPointer(i, i, i * 2, i * 3, i * 4);
            assertEquals("size after add at " + i, i + 1, src.getPointerSize());
        }
        for (int i = 0; i < limit; i += step) {
            assertEquals("xCoordinates at " + i, i, src.getXCoordinates()[i]);
            assertEquals("yCoordinates at " + i, i * 2, src.getYCoordinates()[i]);
            assertEquals("pointerIds at " + i, i * 3, src.getPointerIds()[i]);
            assertEquals("times at " + i, i * 4, src.getTimes()[i]);
        }
    }

    public void testSet() {
        final InputPointers src = new InputPointers(DEFAULT_CAPACITY);
        final int limit = src.getXCoordinates().length * 2 + 10;
        for (int i = 0; i < limit; i++) {
            src.addPointer(i, i * 2, i * 3, i * 4);
        }
        final InputPointers dst = new InputPointers(DEFAULT_CAPACITY);
        dst.set(src);
        assertEquals("size after set", dst.getPointerSize(), src.getPointerSize());
        assertSame("xCoordinates after set", dst.getXCoordinates(), src.getXCoordinates());
        assertSame("yCoordinates after set", dst.getYCoordinates(), src.getYCoordinates());
        assertSame("pointerIds after set", dst.getPointerIds(), src.getPointerIds());
        assertSame("times after set", dst.getTimes(), src.getTimes());
    }

    public void testCopy() {
        final InputPointers src = new InputPointers(DEFAULT_CAPACITY);
        final int limit = 100;
        for (int i = 0; i < limit; i++) {
            src.addPointer(i, i * 2, i * 3, i * 4);
        }
        final InputPointers dst = new InputPointers(DEFAULT_CAPACITY);
        dst.copy(src);
        assertEquals("size after copy", dst.getPointerSize(), src.getPointerSize());
        assertNotSame("xCoordinates after copy", dst.getXCoordinates(), src.getXCoordinates());
        assertNotSame("yCoordinates after copy", dst.getYCoordinates(), src.getYCoordinates());
        assertNotSame("pointerIds after copy", dst.getPointerIds(), src.getPointerIds());
        assertNotSame("times after copy", dst.getTimes(), src.getTimes());
        final int size = dst.getPointerSize();
        assertArrayEquals("xCoordinates values after copy",
                dst.getXCoordinates(), 0, src.getXCoordinates(), 0, size);
        assertArrayEquals("yCoordinates values after copy",
                dst.getYCoordinates(), 0, src.getYCoordinates(), 0, size);
        assertArrayEquals("pointerIds values after copy",
                dst.getPointerIds(), 0, src.getPointerIds(), 0, size);
        assertArrayEquals("times values after copy",
                dst.getTimes(), 0, src.getTimes(), 0, size);
    }

    public void testAppend() {
        final InputPointers src = new InputPointers(DEFAULT_CAPACITY);
        final int srcLen = 100;
        for (int i = 0; i < srcLen; i++) {
            src.addPointer(i, i * 2, i * 3, i * 4);
        }
        final int dstLen = 50;
        final InputPointers dst = new InputPointers(DEFAULT_CAPACITY);
        for (int i = 0; i < dstLen; i++) {
            final int value = -i - 1;
            dst.addPointer(value * 4, value * 3, value * 2, value);
        }
        final InputPointers dstCopy = new InputPointers(DEFAULT_CAPACITY);
        dstCopy.copy(dst);

        dst.append(src, 0, 0);
        assertEquals("size after append zero", dstLen, dst.getPointerSize());
        assertArrayEquals("xCoordinates after append zero",
                dstCopy.getXCoordinates(), 0, dst.getXCoordinates(), 0, dstLen);
        assertArrayEquals("yCoordinates after append zero",
                dstCopy.getYCoordinates(), 0, dst.getYCoordinates(), 0, dstLen);
        assertArrayEquals("pointerIds after append zero",
                dstCopy.getPointerIds(), 0, dst.getPointerIds(), 0, dstLen);
        assertArrayEquals("times after append zero",
                dstCopy.getTimes(), 0, dst.getTimes(), 0, dstLen);

        dst.append(src, 0, srcLen);
        assertEquals("size after append", dstLen + srcLen, dst.getPointerSize());
        assertTrue("primitive length after append",
                dst.getPointerIds().length >= dstLen + srcLen);
        assertArrayEquals("original xCoordinates values after append",
                dstCopy.getXCoordinates(), 0, dst.getXCoordinates(), 0, dstLen);
        assertArrayEquals("original yCoordinates values after append",
                dstCopy.getYCoordinates(), 0, dst.getYCoordinates(), 0, dstLen);
        assertArrayEquals("original pointerIds values after append",
                dstCopy.getPointerIds(), 0, dst.getPointerIds(), 0, dstLen);
        assertArrayEquals("original times values after append",
                dstCopy.getTimes(), 0, dst.getTimes(), 0, dstLen);
        assertArrayEquals("appended xCoordinates values after append",
                src.getXCoordinates(), 0, dst.getXCoordinates(), dstLen, srcLen);
        assertArrayEquals("appended yCoordinates values after append",
                src.getYCoordinates(), 0, dst.getYCoordinates(), dstLen, srcLen);
        assertArrayEquals("appended pointerIds values after append",
                src.getPointerIds(), 0, dst.getPointerIds(), dstLen, srcLen);
        assertArrayEquals("appended times values after append",
                src.getTimes(), 0, dst.getTimes(), dstLen, srcLen);
    }

    public void testAppendResizableIntArray() {
        final int srcLen = 100;
        final int srcPointerId = 1;
        final int[] srcPointerIds = new int[srcLen];
        Arrays.fill(srcPointerIds, srcPointerId);
        final ResizableIntArray srcTimes = new ResizableIntArray(DEFAULT_CAPACITY);
        final ResizableIntArray srcXCoords = new ResizableIntArray(DEFAULT_CAPACITY);
        final ResizableIntArray srcYCoords= new ResizableIntArray(DEFAULT_CAPACITY);
        for (int i = 0; i < srcLen; i++) {
            srcTimes.add(i * 2);
            srcXCoords.add(i * 3);
            srcYCoords.add(i * 4);
        }
        final int dstLen = 50;
        final InputPointers dst = new InputPointers(DEFAULT_CAPACITY);
        for (int i = 0; i < dstLen; i++) {
            final int value = -i - 1;
            dst.addPointer(value * 4, value * 3, value * 2, value);
        }
        final InputPointers dstCopy = new InputPointers(DEFAULT_CAPACITY);
        dstCopy.copy(dst);

        dst.append(srcPointerId, srcTimes, srcXCoords, srcYCoords, 0, 0);
        assertEquals("size after append zero", dstLen, dst.getPointerSize());
        assertArrayEquals("xCoordinates after append zero",
                dstCopy.getXCoordinates(), 0, dst.getXCoordinates(), 0, dstLen);
        assertArrayEquals("yCoordinates after append zero",
                dstCopy.getYCoordinates(), 0, dst.getYCoordinates(), 0, dstLen);
        assertArrayEquals("pointerIds after append zero",
                dstCopy.getPointerIds(), 0, dst.getPointerIds(), 0, dstLen);
        assertArrayEquals("times after append zero",
                dstCopy.getTimes(), 0, dst.getTimes(), 0, dstLen);

        dst.append(srcPointerId, srcTimes, srcXCoords, srcYCoords, 0, srcLen);
        assertEquals("size after append", dstLen + srcLen, dst.getPointerSize());
        assertTrue("primitive length after append",
                dst.getPointerIds().length >= dstLen + srcLen);
        assertArrayEquals("original xCoordinates values after append",
                dstCopy.getXCoordinates(), 0, dst.getXCoordinates(), 0, dstLen);
        assertArrayEquals("original yCoordinates values after append",
                dstCopy.getYCoordinates(), 0, dst.getYCoordinates(), 0, dstLen);
        assertArrayEquals("original pointerIds values after append",
                dstCopy.getPointerIds(), 0, dst.getPointerIds(), 0, dstLen);
        assertArrayEquals("original times values after append",
                dstCopy.getTimes(), 0, dst.getTimes(), 0, dstLen);
        assertArrayEquals("appended xCoordinates values after append",
                srcXCoords.getPrimitiveArray(), 0, dst.getXCoordinates(), dstLen, srcLen);
        assertArrayEquals("appended yCoordinates values after append",
                srcYCoords.getPrimitiveArray(), 0, dst.getYCoordinates(), dstLen, srcLen);
        assertArrayEquals("appended pointerIds values after append",
                srcPointerIds, 0, dst.getPointerIds(), dstLen, srcLen);
        assertArrayEquals("appended times values after append",
                srcTimes.getPrimitiveArray(), 0, dst.getTimes(), dstLen, srcLen);
    }

    private static void assertArrayEquals(String message, int[] expecteds, int expectedPos,
            int[] actuals, int actualPos, int length) {
        if (expecteds == null && actuals == null) {
            return;
        }
        if (expecteds == null || actuals == null) {
            fail(message + ": expecteds=" + expecteds + " actuals=" + actuals);
        }
        for (int i = 0; i < length; i++) {
            assertEquals(message + ": element at " + i,
                    expecteds[i + expectedPos], actuals[i + actualPos]);
        }
    }
}