Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c49c85f8 authored by Tadashi G. Takaoka's avatar Tadashi G. Takaoka
Browse files

Implement ResizableIntArray.setLength and .get 

This change revises ResizableIntArrayTests as well.
parent 721fd573

java/proguard.flags

+4 −0
Original line number Diff line number Diff line
@@ -24,6 +24,10 @@ 
  *;

}



-keep class com.android.inputmethod.latin.ResizableIntArray {

  *;

}



-keep class com.android.inputmethod.latin.spellcheck.SpellCheckerSettingsFragment {

  *;

}

java/src/com/android/inputmethod/latin/ResizableIntArray.java

+19 −9
Original line number Diff line number Diff line
@@ -23,11 +23,18 @@ public class ResizableIntArray { 
    private int[] mArray;

    private int mLength;



    public ResizableIntArray(int capacity) {

    public ResizableIntArray(final int capacity) {

        reset(capacity);

    }



    public void add(int index, int val) {

    public int get(final int index) {

        if (index < 0 || index >= mLength) {

            throw new ArrayIndexOutOfBoundsException("length=" + mLength + "; index=" + index);

        }

        return mArray[index];

    }



    public void add(final int index, final int val) {

        if (mLength < index + 1) {

            mLength = index;

            add(val);
@@ -36,14 +43,14 @@ public class ResizableIntArray { 
        }

    }



    public void add(int val) {

    public void add(final int val) {

        final int nextLength = mLength + 1;

        ensureCapacity(nextLength);

        mArray[mLength] = val;

        mLength = nextLength;

    }



    private void ensureCapacity(int minimumCapacity) {

    private void ensureCapacity(final int minimumCapacity) {

        if (mArray.length < minimumCapacity) {

            final int nextCapacity = mArray.length * 2;

            // The following is the same as newLength =
@@ -60,9 +67,12 @@ public class ResizableIntArray { 
        return mLength;

    }



    // TODO: Implement setLength(int).

    public void setLength(final int newLength) {

        ensureCapacity(newLength);

        mLength = newLength;

    }



    public void reset(int capacity) {

    public void reset(final int capacity) {

        // TODO: Implement primitive array pool.

        mArray = new int[capacity];

        mLength = 0;
@@ -72,20 +82,20 @@ public class ResizableIntArray { 
        return mArray;

    }



    public void set(ResizableIntArray ip) {

    public void set(final ResizableIntArray ip) {

        // TODO: Implement primitive array pool.

        mArray = ip.mArray;

        mLength = ip.mLength;

    }



    public void copy(ResizableIntArray ip) {

    public void copy(final ResizableIntArray ip) {

        // TODO: Avoid useless coping of values.

        ensureCapacity(ip.mLength);

        System.arraycopy(ip.mArray, 0, mArray, 0, ip.mLength);

        mLength = ip.mLength;

    }



    public void append(ResizableIntArray src, int startPos, int length) {

    public void append(final ResizableIntArray src, final int startPos, final int length) {

        final int currentLength = mLength;

        final int newLength = currentLength + length;

        ensureCapacity(newLength);

tests/src/com/android/inputmethod/latin/ResizableIntArrayTests.java

+142 −23
Original line number Diff line number Diff line
@@ -22,50 +22,142 @@ public class ResizableIntArrayTests extends AndroidTestCase { 
    private static final int DEFAULT_CAPACITY = 48;



    public void testNewInstance() {

        final ResizableIntArray src = new ResizableIntArray(DEFAULT_CAPACITY);

        assertEquals("new instance length", 0, src.getLength());

        assertNotNull("new instance array", src.getPrimitiveArray());

    }



    public void testReset() {

        final ResizableIntArray src = new ResizableIntArray(DEFAULT_CAPACITY);

        final int[] array = src.getPrimitiveArray();



        src.reset(DEFAULT_CAPACITY);

        assertEquals("length after reset", 0, src.getLength());

        assertNotSame("array after reset", array, src.getPrimitiveArray());

        assertEquals("new instance length", 0, src.getLength());

        assertNotNull("new instance array", array);

        assertEquals("new instance array length", DEFAULT_CAPACITY, array.length);

    }



    public void testAdd() {

        final ResizableIntArray src = new ResizableIntArray(DEFAULT_CAPACITY);

        final int limit = src.getPrimitiveArray().length * 2 + 10;

        final int[] array = src.getPrimitiveArray();

        int[] array2 = null, array3 = null;

        final int limit = DEFAULT_CAPACITY * 2 + 10;

        for (int i = 0; i < limit; i++) {

            src.add(i);

            assertEquals("length after add " + i, i + 1, src.getLength());

            if (i == DEFAULT_CAPACITY) array2 = src.getPrimitiveArray();

            if (i == DEFAULT_CAPACITY * 2) array3 = src.getPrimitiveArray();

            if (i < DEFAULT_CAPACITY) {

                assertSame("array after add " + i, array, src.getPrimitiveArray());

            } else if (i < DEFAULT_CAPACITY * 2) {

                assertSame("array after add " + i, array2, src.getPrimitiveArray());

            } else if (i < DEFAULT_CAPACITY * 3) {

                assertSame("array after add " + i, array3, src.getPrimitiveArray());

            }

        }

        for (int i = 0; i < limit; i++) {

            assertEquals("value at " + i, i, src.getPrimitiveArray()[i]);

            assertEquals("value at " + i, i, src.get(i));

        }

    }



    public void testAddAt() {

        final ResizableIntArray src = new ResizableIntArray(DEFAULT_CAPACITY);

        final int limit = 1000, step = 100;

        final int limit = DEFAULT_CAPACITY * 10, step = DEFAULT_CAPACITY * 2;

        for (int i = 0; i < limit; i += step) {

            src.add(i, i);

            assertEquals("length after add at " + i, i + 1, src.getLength());

        }

        for (int i = 0; i < limit; i += step) {

            assertEquals("value at " + i, i, src.getPrimitiveArray()[i]);

            assertEquals("value at " + i, i, src.get(i));

        }

    }



    public void testGet() {

        final ResizableIntArray src = new ResizableIntArray(DEFAULT_CAPACITY);

        try {

            final int value = src.get(0);

            fail("get(0) shouldn't succeed");

        } catch (ArrayIndexOutOfBoundsException e) {

            // success

        }

        try {

            final int value = src.get(DEFAULT_CAPACITY);

            fail("get(DEFAULT_CAPACITY) shouldn't succeed");

        } catch (ArrayIndexOutOfBoundsException e) {

            // success

        }



        final int index = DEFAULT_CAPACITY / 2;

        src.add(index, 100);

        assertEquals("legth after add at " + index, index + 1, src.getLength());

        assertEquals("value after add at " + index, 100, src.get(index));

        assertEquals("value after add at 0", 0, src.get(0));

        try {

            final int value = src.get(src.getLength());

            fail("get(length) shouldn't succeed");

        } catch (ArrayIndexOutOfBoundsException e) {

            // success

        }

    }



    public void testReset() {

        final ResizableIntArray src = new ResizableIntArray(DEFAULT_CAPACITY);

        final int[] array = src.getPrimitiveArray();

        for (int i = 0; i < DEFAULT_CAPACITY; i++) {

            src.add(i);

            assertEquals("length after add " + i, i + 1, src.getLength());

        }



        final int smallerLength = DEFAULT_CAPACITY / 2;

        src.reset(smallerLength);

        final int[] array2 = src.getPrimitiveArray();

        assertEquals("length after reset", 0, src.getLength());

        assertNotSame("array after reset", array, array2);



        int[] array3 = null;

        for (int i = 0; i < DEFAULT_CAPACITY; i++) {

            src.add(i);

            assertEquals("length after add " + i, i + 1, src.getLength());

            if (i == smallerLength) array3 = src.getPrimitiveArray();

            if (i < smallerLength) {

                assertSame("array after add " + i, array2, src.getPrimitiveArray());

            } else if (i < smallerLength * 2) {

                assertSame("array after add " + i, array3, src.getPrimitiveArray());

            }

        }

    }



    public void testSetLength() {

        final ResizableIntArray src = new ResizableIntArray(DEFAULT_CAPACITY);

        final int[] array = src.getPrimitiveArray();

        for (int i = 0; i < DEFAULT_CAPACITY; i++) {

            src.add(i);

            assertEquals("length after add " + i, i + 1, src.getLength());

        }



        final int largerLength = DEFAULT_CAPACITY * 2;

        src.setLength(largerLength);

        final int[] array2 = src.getPrimitiveArray();

        assertEquals("length after larger setLength", largerLength, src.getLength());

        assertNotSame("array after larger setLength", array, array2);

        assertEquals("array length after larger setLength", largerLength, array2.length);

        for (int i = 0; i < DEFAULT_CAPACITY; i++) {

            assertEquals("value at " + i, i, src.get(i));

        }

        for (int i = DEFAULT_CAPACITY; i < largerLength; i++) {

            assertEquals("value at " + i, 0, src.get(i));

        }



        final int smallerLength = DEFAULT_CAPACITY / 2;

        src.setLength(smallerLength);

        final int[] array3 = src.getPrimitiveArray();

        assertEquals("length after smaller setLength", smallerLength, src.getLength());

        assertSame("array after smaller setLength", array2, array3);

        assertEquals("array length after smaller setLength", largerLength, array3.length);

        for (int i = 0; i < smallerLength; i++) {

            assertEquals("value at " + i, i, src.get(i));

        }

    }



    public void testSet() {

        final ResizableIntArray src = new ResizableIntArray(DEFAULT_CAPACITY);

        final int limit = src.getPrimitiveArray().length * 2 + 10;

        final int limit = DEFAULT_CAPACITY * 2 + 10;

        for (int i = 0; i < limit; i++) {

            src.add(i);

        }



        final ResizableIntArray dst = new ResizableIntArray(DEFAULT_CAPACITY);

        dst.set(src);

        assertEquals("length after set", dst.getLength(), src.getLength());
@@ -74,27 +166,40 @@ public class ResizableIntArrayTests extends AndroidTestCase { 


    public void testCopy() {

        final ResizableIntArray src = new ResizableIntArray(DEFAULT_CAPACITY);

        final int limit = 100;

        for (int i = 0; i < limit; i++) {

        for (int i = 0; i < DEFAULT_CAPACITY; i++) {

            src.add(i);

        }



        final ResizableIntArray dst = new ResizableIntArray(DEFAULT_CAPACITY);

        final int[] array = dst.getPrimitiveArray();

        dst.copy(src);

        assertEquals("length after copy", dst.getLength(), src.getLength());

        assertSame("array after copy", array, dst.getPrimitiveArray());

        assertNotSame("array after copy", dst.getPrimitiveArray(), src.getPrimitiveArray());

        final int length = dst.getLength();

        assertArrayEquals("values after copy",

                dst.getPrimitiveArray(), 0, src.getPrimitiveArray(), 0, length);

                dst.getPrimitiveArray(), 0, src.getPrimitiveArray(), 0, dst.getLength());



        final int smallerLength = DEFAULT_CAPACITY / 2;

        dst.reset(smallerLength);

        final int[] array2 = dst.getPrimitiveArray();

        dst.copy(src);

        final int[] array3 = dst.getPrimitiveArray();

        assertEquals("length after copy to smaller", dst.getLength(), src.getLength());

        assertNotSame("array after copy to smaller", array2, array3);

        assertNotSame("array after copy to smaller", array3, src.getPrimitiveArray());

        assertArrayEquals("values after copy to smaller",

                dst.getPrimitiveArray(), 0, src.getPrimitiveArray(), 0, dst.getLength());

    }



    public void testAppend() {

        final ResizableIntArray src = new ResizableIntArray(DEFAULT_CAPACITY);

        final int srcLen = 100;

        final int srcLen = DEFAULT_CAPACITY;

        final ResizableIntArray src = new ResizableIntArray(srcLen);

        for (int i = 0; i < srcLen; i++) {

            src.add(i);

        }

        final int dstLen = 50;

        final ResizableIntArray dst = new ResizableIntArray(DEFAULT_CAPACITY);

        final ResizableIntArray dst = new ResizableIntArray(DEFAULT_CAPACITY * 2);

        final int[] array = dst.getPrimitiveArray();

        final int dstLen = DEFAULT_CAPACITY / 2;

        for (int i = 0; i < dstLen; i++) {

            final int value = -i - 1;

            dst.add(value);
@@ -104,17 +209,31 @@ public class ResizableIntArrayTests extends AndroidTestCase { 


        dst.append(src, 0, 0);

        assertEquals("length after append zero", dstLen, dst.getLength());

        assertSame("array after append zero", array, dst.getPrimitiveArray());

        assertArrayEquals("values after append zero",

                dstCopy.getPrimitiveArray(), 0, dst.getPrimitiveArray(), 0, dstLen);



        dst.append(src, 0, srcLen);

        assertEquals("length after append", dstLen + srcLen, dst.getLength());

        assertSame("array after append", array, dst.getPrimitiveArray());

        assertTrue("primitive length after append",

                dst.getPrimitiveArray().length >= dstLen + srcLen);

        assertArrayEquals("original values after append",

                dstCopy.getPrimitiveArray(), 0, dst.getPrimitiveArray(), 0, dstLen);

        assertArrayEquals("appended values after append",

                src.getPrimitiveArray(), 0, dst.getPrimitiveArray(), dstLen, srcLen);



        dst.append(src, 0, srcLen);

        assertEquals("length after 2nd append", dstLen + srcLen * 2, dst.getLength());

        assertNotSame("array after 2nd append", array, dst.getPrimitiveArray());

        assertTrue("primitive length after 2nd append",

                dst.getPrimitiveArray().length >= dstLen + srcLen * 2);

        assertArrayEquals("original values after 2nd append",

                dstCopy.getPrimitiveArray(), 0, dst.getPrimitiveArray(), 0, dstLen);

        assertArrayEquals("appended values after 2nd append",

                src.getPrimitiveArray(), 0, dst.getPrimitiveArray(), dstLen, srcLen);

        assertArrayEquals("appended values after 2nd append",

                src.getPrimitiveArray(), 0, dst.getPrimitiveArray(), dstLen + srcLen, srcLen);

    }



    private static void assertArrayEquals(String message, int[] expecteds, int expectedPos,