diff --git a/java/proguard.flags b/java/proguard.flags
index 163352287b2901cdc965894a866a991b6da5105b..1711b99df6d5ed31622434259f835640e7e94232 100644
--- a/java/proguard.flags
+++ b/java/proguard.flags
@@ -24,6 +24,10 @@
*;
}
+-keep class com.android.inputmethod.latin.ResizableIntArray {
+ *;
+}
+
-keep class com.android.inputmethod.latin.spellcheck.SpellCheckerSettingsFragment {
*;
}
diff --git a/java/src/com/android/inputmethod/latin/ResizableIntArray.java b/java/src/com/android/inputmethod/latin/ResizableIntArray.java
index 2079c0e9980a82978ff10c73ac3d5adac78f9304..6feae9c5a5e03e38eba162e98620b1dfc6537308 100644
--- a/java/src/com/android/inputmethod/latin/ResizableIntArray.java
+++ b/java/src/com/android/inputmethod/latin/ResizableIntArray.java
@@ -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);
diff --git a/tests/src/com/android/inputmethod/latin/ResizableIntArrayTests.java b/tests/src/com/android/inputmethod/latin/ResizableIntArrayTests.java
index 8b869b6ca71e0e364365f96b778058bf56611b39..80e5f9cb1942ca5773c87faf0d04582c8e88020d 100644
--- a/tests/src/com/android/inputmethod/latin/ResizableIntArrayTests.java
+++ b/tests/src/com/android/inputmethod/latin/ResizableIntArrayTests.java
@@ -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,