diff --git a/java/res/values/keypress-vibration-durations.xml b/java/res/values/keypress-vibration-durations.xml
index 9ce5051..ad6bead 100644
--- a/java/res/values/keypress-vibration-durations.xml
+++ b/java/res/values/keypress-vibration-durations.xml
@@ -37,7 +37,7 @@
         <item>MODEL=(SAMSUNG-)?GT-I(930[05][NT]?|9308):MANUFACTURER=samsung,8</item>
         <item>MODEL=(SAMSUNG-)?SGH-(T999[V]?|I747[M]?|N064|N035):MANUFACTURER=samsung,8</item>
         <item>MODEL=(SAMSUNG-)?SCH-(J021|R530|I535|I939):MANUFACTURER=samsung,8</item>
-        <item>MODEL=(SAMSUNG-)?(SCL21|SC-06D|SC-03E]):MANUFACTURER=samsung,8</item>
+        <item>MODEL=(SAMSUNG-)?(SCL21|SC-06D|SC-03E):MANUFACTURER=samsung,8</item>
         <item>MODEL=(SAMSUNG-)?(SHV-210[KLS]?|SPH-L710):MANUFACTURER=samsung,8</item>
         <!-- LG Optimus G -->
         <item>MODEL=LG-E97[013]|LS970|L-01E:MANUFACTURER=LGE,15</item>
diff --git a/java/src/com/android/inputmethod/keyboard/KeyboardSwitcher.java b/java/src/com/android/inputmethod/keyboard/KeyboardSwitcher.java
index c5bd624..83f1090 100644
--- a/java/src/com/android/inputmethod/keyboard/KeyboardSwitcher.java
+++ b/java/src/com/android/inputmethod/keyboard/KeyboardSwitcher.java
@@ -335,10 +335,6 @@
         }
     }
 
-    public boolean isInMomentarySwitchState() {
-        return mState.isInMomentarySwitchState();
-    }
-
     /**
      * Updates state machine to figure out when to automatically switch back to the previous mode.
      */
diff --git a/java/src/com/android/inputmethod/keyboard/MainKeyboardView.java b/java/src/com/android/inputmethod/keyboard/MainKeyboardView.java
index 34464f6..7493df8 100644
--- a/java/src/com/android/inputmethod/keyboard/MainKeyboardView.java
+++ b/java/src/com/android/inputmethod/keyboard/MainKeyboardView.java
@@ -315,9 +315,8 @@
             default:
                 final int longpressTimeout =
                         Settings.getInstance().getCurrent().mKeyLongpressTimeout;
-                if (KeyboardSwitcher.getInstance().isInMomentarySwitchState()) {
-                    // We use longer timeout for sliding finger input started from the symbols
-                    // mode key.
+                if (tracker.isInSlidingKeyInputFromModifier()) {
+                    // We use longer timeout for sliding finger input started from the modifier key.
                     delay = longpressTimeout * 3;
                 } else {
                     delay = longpressTimeout;
diff --git a/java/src/com/android/inputmethod/keyboard/internal/KeySpecParser.java b/java/src/com/android/inputmethod/keyboard/internal/KeySpecParser.java
index b1813a1..ba449ee 100644
--- a/java/src/com/android/inputmethod/keyboard/internal/KeySpecParser.java
+++ b/java/src/com/android/inputmethod/keyboard/internal/KeySpecParser.java
@@ -53,7 +53,9 @@
     private static final int MAX_STRING_REFERENCE_INDIRECTION = 10;
 
     // Constants for parsing.
-    private static final char LABEL_END = '|';
+    private static final char COMMA = ',';
+    private static final char BACKSLASH = '\\';
+    private static final char VERTICAL_BAR = '|';
     private static final String PREFIX_TEXT = "!text/";
     static final String PREFIX_ICON = "!icon/";
     private static final String PREFIX_CODE = "!code/";
@@ -64,6 +66,59 @@
         // Intentional empty constructor for utility class.
     }
 
+    /**
+     * Split the text containing multiple key specifications separated by commas into an array of
+     * key specifications.
+     * A key specification can contain a character escaped by the backslash character, including a
+     * comma character.
+     * Note that an empty key specification will be eliminated from the result array.
+     *
+     * @param text the text containing multiple key specifications.
+     * @return an array of key specification text. Null if the specified <code>text</code> is empty
+     * or has no key specifications.
+     */
+    public static String[] splitKeySpecs(final String text) {
+        final int size = text.length();
+        if (size == 0) {
+            return null;
+        }
+        // Optimization for one-letter key specification.
+        if (size == 1) {
+            return text.charAt(0) == COMMA ? null : new String[] { text };
+        }
+
+        ArrayList<String> list = null;
+        int start = 0;
+        // The characters in question in this loop are COMMA and BACKSLASH. These characters never
+        // match any high or low surrogate character. So it is OK to iterate through with char
+        // index.
+        for (int pos = 0; pos < size; pos++) {
+            final char c = text.charAt(pos);
+            if (c == COMMA) {
+                // Skip empty entry.
+                if (pos - start > 0) {
+                    if (list == null) {
+                        list = CollectionUtils.newArrayList();
+                    }
+                    list.add(text.substring(start, pos));
+                }
+                // Skip comma
+                start = pos + 1;
+            } else if (c == BACKSLASH) {
+                // Skip escape character and escaped character.
+                pos++;
+            }
+        }
+        final String remain = (size - start > 0) ? text.substring(start) : null;
+        if (list == null) {
+            return remain != null ? new String[] { remain } : null;
+        }
+        if (remain != null) {
+            list.add(remain);
+        }
+        return list.toArray(new String[list.size()]);
+    }
+
     private static boolean hasIcon(final String moreKeySpec) {
         return moreKeySpec.startsWith(PREFIX_ICON);
     }
@@ -78,14 +133,14 @@
     }
 
     private static String parseEscape(final String text) {
-        if (text.indexOf(Constants.CSV_ESCAPE) < 0) {
+        if (text.indexOf(BACKSLASH) < 0) {
             return text;
         }
         final int length = text.length();
         final StringBuilder sb = new StringBuilder();
         for (int pos = 0; pos < length; pos++) {
             final char c = text.charAt(pos);
-            if (c == Constants.CSV_ESCAPE && pos + 1 < length) {
+            if (c == BACKSLASH && pos + 1 < length) {
                 // Skip escape char
                 pos++;
                 sb.append(text.charAt(pos));
@@ -97,20 +152,20 @@
     }
 
     private static int indexOfLabelEnd(final String moreKeySpec, final int start) {
-        if (moreKeySpec.indexOf(Constants.CSV_ESCAPE, start) < 0) {
-            final int end = moreKeySpec.indexOf(LABEL_END, start);
+        if (moreKeySpec.indexOf(BACKSLASH, start) < 0) {
+            final int end = moreKeySpec.indexOf(VERTICAL_BAR, start);
             if (end == 0) {
-                throw new KeySpecParserError(LABEL_END + " at " + start + ": " + moreKeySpec);
+                throw new KeySpecParserError(VERTICAL_BAR + " at " + start + ": " + moreKeySpec);
             }
             return end;
         }
         final int length = moreKeySpec.length();
         for (int pos = start; pos < length; pos++) {
             final char c = moreKeySpec.charAt(pos);
-            if (c == Constants.CSV_ESCAPE && pos + 1 < length) {
+            if (c == BACKSLASH && pos + 1 < length) {
                 // Skip escape char
                 pos++;
-            } else if (c == LABEL_END) {
+            } else if (c == VERTICAL_BAR) {
                 return pos;
             }
         }
@@ -136,9 +191,9 @@
             return null;
         }
         if (indexOfLabelEnd(moreKeySpec, end + 1) >= 0) {
-            throw new KeySpecParserError("Multiple " + LABEL_END + ": " + moreKeySpec);
+            throw new KeySpecParserError("Multiple " + VERTICAL_BAR + ": " + moreKeySpec);
         }
-        return parseEscape(moreKeySpec.substring(end + /* LABEL_END */1));
+        return parseEscape(moreKeySpec.substring(end + /* VERTICAL_BAR */1));
     }
 
     static String getOutputText(final String moreKeySpec) {
@@ -169,7 +224,7 @@
         if (hasCode(moreKeySpec)) {
             final int end = indexOfLabelEnd(moreKeySpec, 0);
             if (indexOfLabelEnd(moreKeySpec, end + 1) >= 0) {
-                throw new KeySpecParserError("Multiple " + LABEL_END + ": " + moreKeySpec);
+                throw new KeySpecParserError("Multiple " + VERTICAL_BAR + ": " + moreKeySpec);
             }
             return parseCode(moreKeySpec.substring(end + 1), codesSet, CODE_UNSPECIFIED);
         }
@@ -204,7 +259,7 @@
 
     public static int getIconId(final String moreKeySpec) {
         if (moreKeySpec != null && hasIcon(moreKeySpec)) {
-            final int end = moreKeySpec.indexOf(LABEL_END, PREFIX_ICON.length());
+            final int end = moreKeySpec.indexOf(VERTICAL_BAR, PREFIX_ICON.length());
             final String name = (end < 0) ? moreKeySpec.substring(PREFIX_ICON.length())
                     : moreKeySpec.substring(PREFIX_ICON.length(), end);
             return KeyboardIconsSet.getIconId(name);
@@ -351,7 +406,7 @@
                     final String name = text.substring(pos + prefixLen, end);
                     sb.append(textsSet.getText(name));
                     pos = end - 1;
-                } else if (c == Constants.CSV_ESCAPE) {
+                } else if (c == BACKSLASH) {
                     if (sb != null) {
                         // Append both escape character and escaped character.
                         sb.append(text.substring(pos, Math.min(pos + 2, size)));
@@ -366,7 +421,6 @@
                 text = sb.toString();
             }
         } while (sb != null);
-
         return text;
     }
 
diff --git a/java/src/com/android/inputmethod/keyboard/internal/KeyStyle.java b/java/src/com/android/inputmethod/keyboard/internal/KeyStyle.java
index 5db3ebb..f650569 100644
--- a/java/src/com/android/inputmethod/keyboard/internal/KeyStyle.java
+++ b/java/src/com/android/inputmethod/keyboard/internal/KeyStyle.java
@@ -18,8 +18,6 @@
 
 import android.content.res.TypedArray;
 
-import com.android.inputmethod.latin.StringUtils;
-
 public abstract class KeyStyle {
     private final KeyboardTextsSet mTextsSet;
 
@@ -42,7 +40,7 @@
     protected String[] parseStringArray(final TypedArray a, final int index) {
         if (a.hasValue(index)) {
             final String text = KeySpecParser.resolveTextReference(a.getString(index), mTextsSet);
-            return StringUtils.parseCsvString(text);
+            return KeySpecParser.splitKeySpecs(text);
         }
         return null;
     }
diff --git a/java/src/com/android/inputmethod/keyboard/internal/KeyboardState.java b/java/src/com/android/inputmethod/keyboard/internal/KeyboardState.java
index f18d5ed..9f6374b 100644
--- a/java/src/com/android/inputmethod/keyboard/internal/KeyboardState.java
+++ b/java/src/com/android/inputmethod/keyboard/internal/KeyboardState.java
@@ -574,11 +574,6 @@
         }
     }
 
-    public boolean isInMomentarySwitchState() {
-        return mSwitchState == SWITCH_STATE_MOMENTARY_ALPHA_AND_SYMBOL
-                || mSwitchState == SWITCH_STATE_MOMENTARY_SYMBOL_AND_MORE;
-    }
-
     private static boolean isSpaceCharacter(final int c) {
         return c == Constants.CODE_SPACE || c == Constants.CODE_ENTER;
     }
diff --git a/java/src/com/android/inputmethod/keyboard/internal/MatrixUtils.java b/java/src/com/android/inputmethod/keyboard/internal/MatrixUtils.java
new file mode 100644
index 0000000..4916a15
--- /dev/null
+++ b/java/src/com/android/inputmethod/keyboard/internal/MatrixUtils.java
@@ -0,0 +1,166 @@
+/*
+ * Copyright (C) 2013 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.keyboard.internal;
+
+import com.android.inputmethod.annotations.UsedForTesting;
+
+import android.util.Log;
+
+import java.util.Arrays;
+
+/**
+ * Utilities for matrix operations. Don't instantiate objects inside this class to prevent
+ * unexpected performance regressions.
+ */
+@UsedForTesting
+public class MatrixUtils {
+    private static final String TAG = MatrixUtils.class.getSimpleName();
+    public static class MatrixOperationFailedException extends Exception {
+        private static final String TAG = MatrixOperationFailedException.class.getSimpleName();
+        private static final long serialVersionUID = 4384485606788583829L;
+
+        public MatrixOperationFailedException(String msg) {
+            super(msg);
+            Log.d(TAG, msg);
+        }
+    }
+
+    /**
+     * A utility function to inverse matrix.
+     * Find a pivot and swap the row of squareMatrix0 and squareMatrix1
+     */
+    private static void findPivotAndSwapRow(final int row, final float[][] squareMatrix0,
+            final float[][] squareMatrix1, final int size) {
+        int ip = row;
+        float pivot = Math.abs(squareMatrix0[row][row]);
+        for (int i = row + 1; i < size; ++i) {
+            if (pivot < Math.abs(squareMatrix0[i][row])) {
+                ip = i;
+                pivot = Math.abs(squareMatrix0[i][row]);
+            }
+        }
+        if (ip != row) {
+            for (int j = 0; j < size; ++j) {
+                final float temp0 = squareMatrix0[ip][j];
+                squareMatrix0[ip][j] = squareMatrix0[row][j];
+                squareMatrix0[row][j] = temp0;
+                final float temp1 = squareMatrix1[ip][j];
+                squareMatrix1[ip][j] = squareMatrix1[row][j];
+                squareMatrix1[row][j] = temp1;
+            }
+        }
+    }
+
+    /**
+     * A utility function to inverse matrix. This function calculates answer for each row by
+     * sweeping method of Gauss Jordan elimination
+     */
+    private static void sweep(final int row, final float[][] squareMatrix0,
+            final float[][] squareMatrix1, final int size) throws MatrixOperationFailedException {
+        final float pivot = squareMatrix0[row][row];
+        if (pivot == 0) {
+            throw new MatrixOperationFailedException("Inverse failed. Invalid pivot");
+        }
+        for (int j = 0; j < size; ++j) {
+            squareMatrix0[row][j] /= pivot;
+            squareMatrix1[row][j] /= pivot;
+        }
+        for (int i = 0; i < size; i++) {
+            final float sweepTargetValue = squareMatrix0[i][row];
+            if (i != row) {
+                for (int j = row; j < size; ++j) {
+                    squareMatrix0[i][j] -= sweepTargetValue * squareMatrix0[row][j];
+                }
+                for (int j = 0; j < size; ++j) {
+                    squareMatrix1[i][j] -= sweepTargetValue * squareMatrix1[row][j];
+                }
+            }
+        }
+    }
+
+    /**
+     * A function to inverse matrix.
+     * The inverse matrix of squareMatrix will be output to inverseMatrix. Please notice that
+     * the value of squareMatrix is modified in this function and can't be resuable.
+     */
+    @UsedForTesting
+    public static void inverse(final float[][] squareMatrix,
+            final float[][] inverseMatrix) throws MatrixOperationFailedException {
+        final int size = squareMatrix.length;
+        if (squareMatrix[0].length != size || inverseMatrix.length != size
+                || inverseMatrix[0].length != size) {
+            throw new MatrixOperationFailedException(
+                    "--- invalid length. column should be 2 times larger than row.");
+        }
+        for (int i = 0; i < size; ++i) {
+            Arrays.fill(inverseMatrix[i], 0.0f);
+            inverseMatrix[i][i] = 1.0f;
+        }
+        for (int i = 0; i < size; ++i) {
+            findPivotAndSwapRow(i, squareMatrix, inverseMatrix, size);
+            sweep(i, squareMatrix, inverseMatrix, size);
+        }
+    }
+
+    /**
+     * A matrix operation to multiply m0 and m1.
+     */
+    @UsedForTesting
+    public static void multiply(final float[][] m0, final float[][] m1,
+            final float[][] retval) throws MatrixOperationFailedException {
+        if (m0[0].length != m1.length) {
+            throw new MatrixOperationFailedException(
+                    "--- invalid length for multiply " + m0[0].length + ", " + m1.length);
+        }
+        final int m0h = m0.length;
+        final int m0w = m0[0].length;
+        final int m1w = m1[0].length;
+        if (retval.length != m0h || retval[0].length != m1w) {
+            throw new MatrixOperationFailedException(
+                    "--- invalid length of retval " + retval.length + ", " + retval[0].length);
+        }
+
+        for (int i = 0; i < m0h; i++) {
+            Arrays.fill(retval[i], 0);
+            for (int j = 0; j < m1w; j++) {
+                for (int k = 0; k < m0w; k++) {
+                    retval[i][j] += m0[i][k] * m1[k][j];
+                }
+            }
+        }
+    }
+
+    /**
+     * A utility function to dump the specified matrix in a readable way
+     */
+    @UsedForTesting
+    public static void dump(final String title, final float[][] a) {
+        final int column = a[0].length;
+        final int row = a.length;
+        Log.d(TAG, "Dump matrix: " + title);
+        Log.d(TAG, "/*---------------------");
+        final StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < row; ++i) {
+            sb.setLength(0);
+            for (int j = 0; j < column; ++j) {
+                sb.append(String.format("%4f", a[i][j])).append(' ');
+            }
+            Log.d(TAG, sb.toString());
+        }
+        Log.d(TAG, "---------------------*/");
+    }
+}
diff --git a/java/src/com/android/inputmethod/keyboard/internal/SmoothingUtils.java b/java/src/com/android/inputmethod/keyboard/internal/SmoothingUtils.java
new file mode 100644
index 0000000..e5665bc
--- /dev/null
+++ b/java/src/com/android/inputmethod/keyboard/internal/SmoothingUtils.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2013 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.keyboard.internal;
+
+import com.android.inputmethod.annotations.UsedForTesting;
+import com.android.inputmethod.keyboard.internal.MatrixUtils.MatrixOperationFailedException;
+
+import android.util.Log;
+
+import java.util.Arrays;
+
+/**
+ * Utilities to smooth coordinates. Currently, we calculate 3d least squares formula by using
+ * Lagrangian smoothing
+ */
+@UsedForTesting
+public class SmoothingUtils {
+    private static final String TAG = SmoothingUtils.class.getSimpleName();
+    private static final boolean DEBUG = false;
+
+    private SmoothingUtils() {
+        // not allowed to instantiate publicly
+    }
+
+    /**
+     * Find a most likely 3d least squares formula for specified coordinates.
+     * "retval" should be a 1x4 size matrix.
+     */
+    @UsedForTesting
+    public static void get3DParameters(final float[] xs, final float[] ys,
+            final float[][] retval) throws MatrixOperationFailedException {
+        final int COEFF_COUNT = 4; // Coefficient count for 3d smoothing
+        if (retval.length != COEFF_COUNT || retval[0].length != 1) {
+            Log.d(TAG, "--- invalid length of 3d retval " + retval.length + ", "
+                    + retval[0].length);
+            return;
+        }
+        final int N = xs.length;
+        // TODO: Never isntantiate the matrix
+        final float[][] m0 = new float[COEFF_COUNT][COEFF_COUNT];
+        final float[][] m0Inv = new float[COEFF_COUNT][COEFF_COUNT];
+        final float[][] m1 = new float[COEFF_COUNT][N];
+        final float[][] m2 = new float[N][1];
+
+        // m0
+        for (int i = 0; i < COEFF_COUNT; ++i) {
+            Arrays.fill(m0[i], 0);
+            for (int j = 0; j < COEFF_COUNT; ++j) {
+                final int pow = i + j;
+                for (int k = 0; k < N; ++k) {
+                    m0[i][j] += (float) Math.pow((double) xs[k], pow);
+                }
+            }
+        }
+        // m0Inv
+        MatrixUtils.inverse(m0, m0Inv);
+        if (DEBUG) {
+            MatrixUtils.dump("m0-1", m0Inv);
+        }
+
+        // m1
+        for (int i = 0; i < COEFF_COUNT; ++i) {
+            for (int j = 0; j < N; ++j) {
+                m1[i][j] = (i == 0) ? 1.0f : m1[i - 1][j] * xs[j];
+            }
+        }
+
+        // m2
+        for (int i = 0; i < N; ++i) {
+            m2[i][0] = ys[i];
+        }
+
+        final float[][] m0Invxm1 = new float[COEFF_COUNT][N];
+        if (DEBUG) {
+            MatrixUtils.dump("a0", m0Inv);
+            MatrixUtils.dump("a1", m1);
+        }
+        MatrixUtils.multiply(m0Inv, m1, m0Invxm1);
+        if (DEBUG) {
+            MatrixUtils.dump("a2", m0Invxm1);
+            MatrixUtils.dump("a3", m2);
+        }
+        MatrixUtils.multiply(m0Invxm1, m2, retval);
+        if (DEBUG) {
+            MatrixUtils.dump("result", retval);
+        }
+    }
+}
diff --git a/java/src/com/android/inputmethod/latin/AdditionalFeaturesSettingUtils.java b/java/src/com/android/inputmethod/latin/AdditionalFeaturesSettingUtils.java
new file mode 100644
index 0000000..0fdaea5
--- /dev/null
+++ b/java/src/com/android/inputmethod/latin/AdditionalFeaturesSettingUtils.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2013 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 com.android.inputmethodcommon.InputMethodSettingsFragment;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+
+/**
+ * Utility class for managing additional features settings.
+ */
+public class AdditionalFeaturesSettingUtils {
+    public static final int ADDITIONAL_FEATURES_SETTINGS_SIZE = 0;
+
+    private AdditionalFeaturesSettingUtils() {
+        // This utility class is not publicly instantiable.
+    }
+
+    public static void addAdditionalFeaturesPreferences(
+            final Context context, final InputMethodSettingsFragment settingsFragment) {
+        // do nothing.
+    }
+
+    public static void readAdditionalFeaturesPreferencesIntoArray(
+            final SharedPreferences prefs, final int[] additionalFeaturesPreferences) {
+        // do nothing.
+    }
+
+    public static int[] getAdditionalNativeSuggestOptions() {
+        return Settings.getInstance().getCurrent().mAdditionalFeaturesSettingValues;
+    }
+}
diff --git a/java/src/com/android/inputmethod/latin/AdditionalSubtype.java b/java/src/com/android/inputmethod/latin/AdditionalSubtype.java
index 99b95ea..85b14d8 100644
--- a/java/src/com/android/inputmethod/latin/AdditionalSubtype.java
+++ b/java/src/com/android/inputmethod/latin/AdditionalSubtype.java
@@ -49,13 +49,14 @@
                 && SubtypeLocale.isExceptionalLocale(localeString)) {
             final String layoutDisplayName = SubtypeLocale.getKeyboardLayoutSetDisplayName(
                     keyboardLayoutSetName);
-            layoutDisplayNameExtraValue = StringUtils.appendToCsvIfNotExists(
+            layoutDisplayNameExtraValue = StringUtils.appendToCommaSplittableTextIfNotExists(
                     UNTRANSLATABLE_STRING_IN_SUBTYPE_NAME + "=" + layoutDisplayName, extraValue);
         } else {
             layoutDisplayNameExtraValue = extraValue;
         }
-        final String additionalSubtypeExtraValue = StringUtils.appendToCsvIfNotExists(
-                IS_ADDITIONAL_SUBTYPE, layoutDisplayNameExtraValue);
+        final String additionalSubtypeExtraValue =
+                StringUtils.appendToCommaSplittableTextIfNotExists(
+                        IS_ADDITIONAL_SUBTYPE, layoutDisplayNameExtraValue);
         final int nameId = SubtypeLocale.getSubtypeNameId(localeString, keyboardLayoutSetName);
         return new InputMethodSubtype(nameId, R.drawable.ic_subtype_keyboard,
                 localeString, KEYBOARD_MODE,
@@ -66,8 +67,9 @@
         final String localeString = subtype.getLocale();
         final String keyboardLayoutSetName = SubtypeLocale.getKeyboardLayoutSetName(subtype);
         final String layoutExtraValue = KEYBOARD_LAYOUT_SET + "=" + keyboardLayoutSetName;
-        final String extraValue = StringUtils.removeFromCsvIfExists(layoutExtraValue,
-                StringUtils.removeFromCsvIfExists(IS_ADDITIONAL_SUBTYPE, subtype.getExtraValue()));
+        final String extraValue = StringUtils.removeFromCommaSplittableTextIfExists(
+                layoutExtraValue, StringUtils.removeFromCommaSplittableTextIfExists(
+                        IS_ADDITIONAL_SUBTYPE, subtype.getExtraValue()));
         final String basePrefSubtype = localeString + LOCALE_AND_LAYOUT_SEPARATOR
                 + keyboardLayoutSetName;
         return extraValue.isEmpty() ? basePrefSubtype
diff --git a/java/src/com/android/inputmethod/latin/BinaryDictionary.java b/java/src/com/android/inputmethod/latin/BinaryDictionary.java
index c644a77..aad129d 100644
--- a/java/src/com/android/inputmethod/latin/BinaryDictionary.java
+++ b/java/src/com/android/inputmethod/latin/BinaryDictionary.java
@@ -136,6 +136,8 @@
         final InputPointers ips = composer.getInputPointers();
         final int inputSize = isGesture ? ips.getPointerSize() : composerSize;
         mNativeSuggestOptions.setIsGesture(isGesture);
+        mNativeSuggestOptions.setAdditionalFeaturesOptions(
+                AdditionalFeaturesSettingUtils.getAdditionalNativeSuggestOptions());
         // proximityInfo and/or prevWordForBigrams may not be null.
         final int count = getSuggestionsNative(mNativeDict, proximityInfo.getNativeProximityInfo(),
                 getTraverseSession(sessionId).getSession(), ips.getXCoordinates(),
diff --git a/java/src/com/android/inputmethod/latin/Constants.java b/java/src/com/android/inputmethod/latin/Constants.java
index 86bb255..64c14d3 100644
--- a/java/src/com/android/inputmethod/latin/Constants.java
+++ b/java/src/com/android/inputmethod/latin/Constants.java
@@ -215,10 +215,6 @@
         }
     }
 
-    // Constants for CSV parsing.
-    public static final char CSV_SEPARATOR = ',';
-    public static final char CSV_ESCAPE = '\\';
-
     private Constants() {
         // This utility class is not publicly instantiable.
     }
diff --git a/java/src/com/android/inputmethod/latin/InputAttributes.java b/java/src/com/android/inputmethod/latin/InputAttributes.java
index dd58db5..1f673e9 100644
--- a/java/src/com/android/inputmethod/latin/InputAttributes.java
+++ b/java/src/com/android/inputmethod/latin/InputAttributes.java
@@ -199,6 +199,6 @@
         if (editorInfo == null) return false;
         final String findingKey = (packageName != null) ? packageName + "." + key
                 : key;
-        return StringUtils.containsInCsv(findingKey, editorInfo.privateImeOptions);
+        return StringUtils.containsInCommaSplittableText(findingKey, editorInfo.privateImeOptions);
     }
 }
diff --git a/java/src/com/android/inputmethod/latin/LatinIME.java b/java/src/com/android/inputmethod/latin/LatinIME.java
index 592db35..cebc93c 100644
--- a/java/src/com/android/inputmethod/latin/LatinIME.java
+++ b/java/src/com/android/inputmethod/latin/LatinIME.java
@@ -2369,9 +2369,11 @@
         // Please note that if mSuggest is null, it means that everything is off: suggestion
         // and correction, so we shouldn't try to show the hint
         final boolean showingAddToDictionaryHint =
-                SuggestedWordInfo.KIND_TYPED == suggestionInfo.mKind && mSuggest != null
-                // If the suggestion is not in the dictionary, the hint should be shown.
-                && !AutoCorrection.isValidWord(mSuggest, suggestion, true);
+                (SuggestedWordInfo.KIND_TYPED == suggestionInfo.mKind
+                        || SuggestedWordInfo.KIND_OOV_CORRECTION == suggestionInfo.mKind)
+                        && mSuggest != null
+                        // If the suggestion is not in the dictionary, the hint should be shown.
+                        && !AutoCorrection.isValidWord(mSuggest, suggestion, true);
 
         if (mSettings.isInternal()) {
             Stats.onSeparator((char)Constants.CODE_SPACE,
diff --git a/java/src/com/android/inputmethod/latin/NativeSuggestOptions.java b/java/src/com/android/inputmethod/latin/NativeSuggestOptions.java
index 4425f07..2915513 100644
--- a/java/src/com/android/inputmethod/latin/NativeSuggestOptions.java
+++ b/java/src/com/android/inputmethod/latin/NativeSuggestOptions.java
@@ -22,7 +22,8 @@
     private static final int USE_FULL_EDIT_DISTANCE = 1;
     private static final int OPTIONS_SIZE = 2;
 
-    private final int[] mOptions = new int[OPTIONS_SIZE];
+    private final int[] mOptions = new int[OPTIONS_SIZE
+            + AdditionalFeaturesSettingUtils.ADDITIONAL_FEATURES_SETTINGS_SIZE];
 
     public void setIsGesture(final boolean value) {
         setBooleanOption(IS_GESTURE, value);
@@ -32,6 +33,12 @@
         setBooleanOption(USE_FULL_EDIT_DISTANCE, value);
     }
 
+    public void setAdditionalFeaturesOptions(final int[] additionalOptions) {
+        for (int i = 0; i < additionalOptions.length; i++) {
+            setIntegerOption(OPTIONS_SIZE + i, additionalOptions[i]);
+        }
+    }
+
     public int[] getOptions() {
         return mOptions;
     }
@@ -39,4 +46,8 @@
     private void setBooleanOption(final int key, final boolean value) {
         mOptions[key] = value ? 1 : 0;
     }
+
+    private void setIntegerOption(final int key, final int value) {
+        mOptions[key] = value;
+    }
 }
diff --git a/java/src/com/android/inputmethod/latin/ResourceUtils.java b/java/src/com/android/inputmethod/latin/ResourceUtils.java
index a9fba53..0eb8b4f 100644
--- a/java/src/com/android/inputmethod/latin/ResourceUtils.java
+++ b/java/src/com/android/inputmethod/latin/ResourceUtils.java
@@ -27,6 +27,7 @@
 
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.regex.PatternSyntaxException;
 
 public final class ResourceUtils {
     private static final String TAG = ResourceUtils.class.getSimpleName();
@@ -83,22 +84,39 @@
             return overrideValue;
         }
 
-        final String defaultValue = findDefaultConstant(overrideArray);
-        // The defaultValue might be an empty string.
-        if (defaultValue == null) {
-            Log.w(TAG, "Couldn't find override value nor default value:"
-                    + " resource="+ res.getResourceEntryName(overrideResId)
-                    + " build=" + sBuildKeyValuesDebugString);
-        } else {
-            Log.i(TAG, "Found default value:"
-                    + " resource="+ res.getResourceEntryName(overrideResId)
-                    + " build=" + sBuildKeyValuesDebugString
-                    + " default=" + defaultValue);
+        String defaultValue = null;
+        try {
+            defaultValue = findDefaultConstant(overrideArray);
+            // The defaultValue might be an empty string.
+            if (defaultValue == null) {
+                Log.w(TAG, "Couldn't find override value nor default value:"
+                        + " resource="+ res.getResourceEntryName(overrideResId)
+                        + " build=" + sBuildKeyValuesDebugString);
+            } else {
+                Log.i(TAG, "Found default value:"
+                        + " resource="+ res.getResourceEntryName(overrideResId)
+                        + " build=" + sBuildKeyValuesDebugString
+                        + " default=" + defaultValue);
+            }
+        } catch (final DeviceOverridePatternSyntaxError e) {
+            Log.w(TAG, "Syntax error, ignored", e);
         }
         sDeviceOverrideValueMap.put(key, defaultValue);
         return defaultValue;
     }
 
+    @SuppressWarnings("serial")
+    static class DeviceOverridePatternSyntaxError extends Exception {
+        public DeviceOverridePatternSyntaxError(final String message, final String expression) {
+            this(message, expression, null);
+        }
+
+        public DeviceOverridePatternSyntaxError(final String message, final String expression,
+                final Throwable throwable) {
+            super(message + ": " + expression, throwable);
+        }
+    }
+
     /**
      * Find the condition that fulfills specified key value pairs from an array of
      * "condition,constant", and return the corresponding string constant. A condition is
@@ -123,10 +141,12 @@
         if (conditionConstantArray == null || keyValuePairs == null) {
             return null;
         }
+        String foundValue = null;
         for (final String conditionConstant : conditionConstantArray) {
             final int posComma = conditionConstant.indexOf(',');
             if (posComma < 0) {
-                throw new RuntimeException("Array element has no comma: " + conditionConstant);
+                Log.w(TAG, "Array element has no comma: " + conditionConstant);
+                continue;
             }
             final String condition = conditionConstant.substring(0, posComma);
             if (condition.isEmpty()) {
@@ -134,44 +154,59 @@
                 // {@link #findConstantForDefault(String[])}.
                 continue;
             }
-            if (fulfillsCondition(keyValuePairs, condition)) {
-                return conditionConstant.substring(posComma + 1);
+            try {
+                if (fulfillsCondition(keyValuePairs, condition)) {
+                    // Take first match
+                    if (foundValue == null) {
+                        foundValue = conditionConstant.substring(posComma + 1);
+                    }
+                    // And continue walking through all conditions.
+                }
+            } catch (final DeviceOverridePatternSyntaxError e) {
+                Log.w(TAG, "Syntax error, ignored", e);
             }
         }
-        return null;
+        return foundValue;
     }
 
     private static boolean fulfillsCondition(final HashMap<String,String> keyValuePairs,
-            final String condition) {
+            final String condition) throws DeviceOverridePatternSyntaxError {
         final String[] patterns = condition.split(":");
         // Check all patterns in a condition are true
+        boolean matchedAll = true;
         for (final String pattern : patterns) {
             final int posEqual = pattern.indexOf('=');
             if (posEqual < 0) {
-                throw new RuntimeException("Pattern has no '=': " + condition);
+                throw new DeviceOverridePatternSyntaxError("Pattern has no '='", condition);
             }
             final String key = pattern.substring(0, posEqual);
             final String value = keyValuePairs.get(key);
             if (value == null) {
-                throw new RuntimeException("Found unknown key: " + condition);
+                throw new DeviceOverridePatternSyntaxError("Unknown key", condition);
             }
             final String patternRegexpValue = pattern.substring(posEqual + 1);
-            if (!value.matches(patternRegexpValue)) {
-                return false;
+            try {
+                if (!value.matches(patternRegexpValue)) {
+                    matchedAll = false;
+                    // And continue walking through all patterns.
+                }
+            } catch (final PatternSyntaxException e) {
+                throw new DeviceOverridePatternSyntaxError("Syntax error", condition, e);
             }
         }
-        return true;
+        return matchedAll;
     }
 
     @UsedForTesting
-    static String findDefaultConstant(final String[] conditionConstantArray) {
+    static String findDefaultConstant(final String[] conditionConstantArray)
+            throws DeviceOverridePatternSyntaxError {
         if (conditionConstantArray == null) {
             return null;
         }
         for (final String condition : conditionConstantArray) {
             final int posComma = condition.indexOf(',');
             if (posComma < 0) {
-                throw new RuntimeException("Array element has no comma: " + condition);
+                throw new DeviceOverridePatternSyntaxError("Array element has no comma", condition);
             }
             if (posComma == 0) { // condition is empty.
                 return condition.substring(posComma + 1);
diff --git a/java/src/com/android/inputmethod/latin/SeekBarDialogPreference.java b/java/src/com/android/inputmethod/latin/SeekBarDialogPreference.java
index 7c4156c..3ea9fed 100644
--- a/java/src/com/android/inputmethod/latin/SeekBarDialogPreference.java
+++ b/java/src/com/android/inputmethod/latin/SeekBarDialogPreference.java
@@ -32,6 +32,7 @@
         public int readValue(final String key);
         public int readDefaultValue(final String key);
         public void writeValue(final int value, final String key);
+        public void writeDefaultValue(final String key);
         public void feedbackValue(final int value);
     }
 
@@ -122,12 +123,16 @@
     @Override
     public void onClick(final DialogInterface dialog, final int which) {
         super.onClick(dialog, which);
+        final String key = getKey();
         if (which == DialogInterface.BUTTON_NEUTRAL) {
-            setValue(clipValue(mValueProxy.readDefaultValue(getKey())), false /* fromUser */);
+            setValue(clipValue(mValueProxy.readDefaultValue(key)), false /* fromUser */);
+            mValueProxy.writeDefaultValue(key);
+            return;
         }
-        if (which != DialogInterface.BUTTON_NEGATIVE) {
+        if (which == DialogInterface.BUTTON_POSITIVE) {
             setSummary(mValueView.getText());
-            mValueProxy.writeValue(getClippedValueFromProgress(mSeekBar.getProgress()), getKey());
+            mValueProxy.writeValue(getClippedValueFromProgress(mSeekBar.getProgress()), key);
+            return;
         }
     }
 
diff --git a/java/src/com/android/inputmethod/latin/SettingsFragment.java b/java/src/com/android/inputmethod/latin/SettingsFragment.java
index 835ef7b..7225cd6 100644
--- a/java/src/com/android/inputmethod/latin/SettingsFragment.java
+++ b/java/src/com/android/inputmethod/latin/SettingsFragment.java
@@ -207,6 +207,8 @@
 
         if (!Settings.readFromBuildConfigIfGestureInputEnabled(res)) {
             removePreference(Settings.PREF_GESTURE_SETTINGS, getPreferenceScreen());
+        } else {
+            AdditionalFeaturesSettingUtils.addAdditionalFeaturesPreferences(context, this);
         }
 
         setupKeyLongpressTimeoutSettings(prefs, res);
@@ -327,6 +329,11 @@
             }
 
             @Override
+            public void writeDefaultValue(final String key) {
+                sp.edit().remove(key).apply();
+            }
+
+            @Override
             public int readValue(final String key) {
                 return Settings.readKeypressVibrationDuration(sp, res);
             }
@@ -357,6 +364,11 @@
             }
 
             @Override
+            public void writeDefaultValue(final String key) {
+                sp.edit().remove(key).apply();
+            }
+
+            @Override
             public int readValue(final String key) {
                 return Settings.readKeyLongpressTimeout(sp, res);
             }
@@ -395,6 +407,11 @@
             }
 
             @Override
+            public void writeDefaultValue(final String key) {
+                sp.edit().remove(key).apply();
+            }
+
+            @Override
             public int readValue(final String key) {
                 return getPercentageFromValue(Settings.readKeypressSoundVolume(sp, res));
             }
diff --git a/java/src/com/android/inputmethod/latin/SettingsValues.java b/java/src/com/android/inputmethod/latin/SettingsValues.java
index 615b2df..0910244 100644
--- a/java/src/com/android/inputmethod/latin/SettingsValues.java
+++ b/java/src/com/android/inputmethod/latin/SettingsValues.java
@@ -80,6 +80,10 @@
     private final boolean mVoiceKeyEnabled;
     private final boolean mVoiceKeyOnMain;
 
+    // Setting values for additional features
+    public final int[] mAdditionalFeaturesSettingValues =
+            new int[AdditionalFeaturesSettingUtils.ADDITIONAL_FEATURES_SETTINGS_SIZE];
+
     // Debug settings
     public final boolean mIsInternal;
 
@@ -96,7 +100,7 @@
         mWordConnectors =
                 StringUtils.toCodePointArray(res.getString(R.string.symbols_word_connectors));
         Arrays.sort(mWordConnectors);
-        final String[] suggestPuncsSpec = StringUtils.parseCsvString(res.getString(
+        final String[] suggestPuncsSpec = KeySpecParser.splitKeySpecs(res.getString(
                 R.string.suggested_punctuations));
         mSuggestPuncList = createSuggestPuncList(suggestPuncsSpec);
         mWordSeparators = res.getString(R.string.symbols_word_separators);
@@ -149,6 +153,8 @@
                 Settings.PREF_SHOW_SUGGESTIONS_SETTING,
                 res.getString(R.string.prefs_suggestion_visibility_default_value));
         mSuggestionVisibility = createSuggestionVisibility(res, showSuggestionsSetting);
+        AdditionalFeaturesSettingUtils.readAdditionalFeaturesPreferencesIntoArray(
+                prefs, mAdditionalFeaturesSettingValues);
         mIsInternal = Settings.isInternal(prefs);
     }
 
diff --git a/java/src/com/android/inputmethod/latin/StringUtils.java b/java/src/com/android/inputmethod/latin/StringUtils.java
index ab050d7..c2fd4fb 100644
--- a/java/src/com/android/inputmethod/latin/StringUtils.java
+++ b/java/src/com/android/inputmethod/latin/StringUtils.java
@@ -35,33 +35,55 @@
         return text.codePointCount(0, text.length());
     }
 
-    public static boolean containsInArray(final String key, final String[] array) {
+    public static boolean containsInArray(final String text, final String[] array) {
         for (final String element : array) {
-            if (key.equals(element)) return true;
+            if (text.equals(element)) return true;
         }
         return false;
     }
 
-    public static boolean containsInCsv(final String key, final String csv) {
-        if (TextUtils.isEmpty(csv)) return false;
-        return containsInArray(key, csv.split(","));
+    /**
+     * Comma-Splittable Text is similar to Comma-Separated Values (CSV) but has much simpler syntax.
+     * Unlike CSV, Comma-Splittable Text has no escaping mechanism, so that the text can't contain
+     * a comma character in it.
+     */
+    private static final String SEPARATOR_FOR_COMMA_SPLITTABLE_TEXT = ",";
+
+    public static boolean containsInCommaSplittableText(final String text,
+            final String extraValues) {
+        if (TextUtils.isEmpty(extraValues)) {
+            return false;
+        }
+        return containsInArray(text, extraValues.split(SEPARATOR_FOR_COMMA_SPLITTABLE_TEXT));
     }
 
-    public static String appendToCsvIfNotExists(final String key, final String csv) {
-        if (TextUtils.isEmpty(csv)) return key;
-        if (containsInCsv(key, csv)) return csv;
-        return csv + "," + key;
+    public static String appendToCommaSplittableTextIfNotExists(final String text,
+            final String extraValues) {
+        if (TextUtils.isEmpty(extraValues)) {
+            return text;
+        }
+        if (containsInCommaSplittableText(text, extraValues)) {
+            return extraValues;
+        }
+        return extraValues + SEPARATOR_FOR_COMMA_SPLITTABLE_TEXT + text;
     }
 
-    public static String removeFromCsvIfExists(final String key, final String csv) {
-        if (TextUtils.isEmpty(csv)) return "";
-        final String[] elements = csv.split(",");
-        if (!containsInArray(key, elements)) return csv;
+    public static String removeFromCommaSplittableTextIfExists(final String text,
+            final String extraValues) {
+        if (TextUtils.isEmpty(extraValues)) {
+            return "";
+        }
+        final String[] elements = extraValues.split(SEPARATOR_FOR_COMMA_SPLITTABLE_TEXT);
+        if (!containsInArray(text, elements)) {
+            return extraValues;
+        }
         final ArrayList<String> result = CollectionUtils.newArrayList(elements.length - 1);
         for (final String element : elements) {
-            if (!key.equals(element)) result.add(element);
+            if (!text.equals(element)) {
+                result.add(element);
+            }
         }
-        return TextUtils.join(",", result);
+        return TextUtils.join(SEPARATOR_FOR_COMMA_SPLITTABLE_TEXT, result);
     }
 
     /**
@@ -131,44 +153,6 @@
         return codePoints;
     }
 
-    public static String[] parseCsvString(final String text) {
-        final int size = text.length();
-        if (size == 0) {
-            return null;
-        }
-        if (codePointCount(text) == 1) {
-            return text.codePointAt(0) == Constants.CSV_SEPARATOR ? null : new String[] { text };
-        }
-
-        ArrayList<String> list = null;
-        int start = 0;
-        for (int pos = 0; pos < size; pos++) {
-            final char c = text.charAt(pos);
-            if (c == Constants.CSV_SEPARATOR) {
-                // Skip empty entry.
-                if (pos - start > 0) {
-                    if (list == null) {
-                        list = CollectionUtils.newArrayList();
-                    }
-                    list.add(text.substring(start, pos));
-                }
-                // Skip comma
-                start = pos + 1;
-            } else if (c == Constants.CSV_ESCAPE) {
-                // Skip escape character and escaped character.
-                pos++;
-            }
-        }
-        final String remain = (size - start > 0) ? text.substring(start) : null;
-        if (list == null) {
-            return remain != null ? new String[] { remain } : null;
-        }
-        if (remain != null) {
-            list.add(remain);
-        }
-        return list.toArray(new String[list.size()]);
-    }
-
     // This method assumes the text is not null. For the empty string, it returns CAPITALIZE_NONE.
     public static int getCapitalizationType(final String text) {
         // If the first char is not uppercase, then the word is either all lower case or
diff --git a/java/src/com/android/inputmethod/latin/SuggestedWords.java b/java/src/com/android/inputmethod/latin/SuggestedWords.java
index dfddb0f..1f45327 100644
--- a/java/src/com/android/inputmethod/latin/SuggestedWords.java
+++ b/java/src/com/android/inputmethod/latin/SuggestedWords.java
@@ -132,7 +132,10 @@
         public static final int KIND_APP_DEFINED = 6; // Suggested by the application
         public static final int KIND_SHORTCUT = 7; // A shortcut
         public static final int KIND_PREDICTION = 8; // A prediction (== a suggestion with no input)
-        public static final int KIND_RESUMED = 9; // A resumed suggestion (comes from a span)
+        // KIND_RESUMED: A resumed suggestion (comes from a span, currently this type is used only
+        // in java for re-correction)
+        public static final int KIND_RESUMED = 9;
+        public static final int KIND_OOV_CORRECTION = 10; // Most probable string correction
 
         public static final int KIND_MASK_FLAGS = 0xFFFFFF00; // Mask to get the flags
         public static final int KIND_FLAG_POSSIBLY_OFFENSIVE = 0x80000000;
diff --git a/java/src/com/android/inputmethod/latin/personalization/AccountUtils.java b/java/src/com/android/inputmethod/latin/personalization/AccountUtils.java
index 93687e1..a446672 100644
--- a/java/src/com/android/inputmethod/latin/personalization/AccountUtils.java
+++ b/java/src/com/android/inputmethod/latin/personalization/AccountUtils.java
@@ -23,6 +23,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Locale;
 
 public class AccountUtils {
     private AccountUtils() {
@@ -44,4 +45,22 @@
         }
         return retval;
     }
+
+    /**
+     * Get all device accounts having specified domain name.
+     * @param context application context
+     * @param domain domain name used for filtering
+     * @return List of account names that contain the specified domain name
+     */
+    public static List<String> getDeviceAccountsWithDomain(
+            final Context context, final String domain) {
+        final ArrayList<String> retval = new ArrayList<String>();
+        final String atDomain = "@" + domain.toLowerCase(Locale.ROOT);
+        for (final Account account : getAccounts(context)) {
+            if (account.name.toLowerCase(Locale.ROOT).endsWith(atDomain)) {
+                retval.add(account.name);
+            }
+        }
+        return retval;
+    }
 }
diff --git a/java/src/com/android/inputmethod/latin/suggestions/SuggestionStripView.java b/java/src/com/android/inputmethod/latin/suggestions/SuggestionStripView.java
index 1113939..9764610 100644
--- a/java/src/com/android/inputmethod/latin/suggestions/SuggestionStripView.java
+++ b/java/src/com/android/inputmethod/latin/suggestions/SuggestionStripView.java
@@ -250,10 +250,12 @@
         }
 
         private CharSequence getStyledSuggestionWord(final SuggestedWords suggestedWords,
-                final int pos) {
-            final String word = suggestedWords.getWord(pos);
-            final boolean isAutoCorrect = pos == 1 && suggestedWords.willAutoCorrect();
-            final boolean isTypedWordValid = pos == 0 && suggestedWords.mTypedWordValid;
+                final int indexInSuggestedWords) {
+            final String word = suggestedWords.getWord(indexInSuggestedWords);
+            final boolean isAutoCorrect = indexInSuggestedWords == 1
+                    && suggestedWords.willAutoCorrect();
+            final boolean isTypedWordValid = indexInSuggestedWords == 0
+                    && suggestedWords.mTypedWordValid;
             if (!isAutoCorrect && !isTypedWordValid)
                 return word;
 
@@ -270,28 +272,31 @@
             return spannedWord;
         }
 
-        private int getWordPosition(final int index, final SuggestedWords suggestedWords) {
+        private int getIndexInSuggestedWords(final int indexInStrip,
+                final SuggestedWords suggestedWords) {
             // TODO: This works for 3 suggestions. Revisit this algorithm when there are 5 or more
             // suggestions.
-            final int centerPos = suggestedWords.willAutoCorrect() ? 1 : 0;
-            if (index == mCenterSuggestionIndex) {
-                return centerPos;
-            } else if (index == centerPos) {
+            final int mostImportantIndexInSuggestedWords = suggestedWords.willAutoCorrect() ? 1 : 0;
+            if (indexInStrip == mCenterSuggestionIndex) {
+                return mostImportantIndexInSuggestedWords;
+            } else if (indexInStrip == mostImportantIndexInSuggestedWords) {
                 return mCenterSuggestionIndex;
             } else {
-                return index;
+                return indexInStrip;
             }
         }
 
-        private int getSuggestionTextColor(final int index, final SuggestedWords suggestedWords,
-                final int pos) {
+        private int getSuggestionTextColor(final int indexInStrip,
+                final SuggestedWords suggestedWords) {
+            final int indexInSuggestedWords = getIndexInSuggestedWords(
+                    indexInStrip, suggestedWords);
             // TODO: Need to revisit this logic with bigram suggestions
-            final boolean isSuggested = (pos != 0);
+            final boolean isSuggested = (indexInSuggestedWords != 0);
 
             final int color;
-            if (index == mCenterSuggestionIndex && suggestedWords.willAutoCorrect()) {
+            if (indexInStrip == mCenterSuggestionIndex && suggestedWords.willAutoCorrect()) {
                 color = mColorAutoCorrect;
-            } else if (index == mCenterSuggestionIndex && suggestedWords.mTypedWordValid) {
+            } else if (indexInStrip == mCenterSuggestionIndex && suggestedWords.mTypedWordValid) {
                 color = mColorValidTypedWord;
             } else if (isSuggested) {
                 color = mColorSuggested;
@@ -301,7 +306,7 @@
             if (LatinImeLogger.sDBG && suggestedWords.size() > 1) {
                 // If we auto-correct, then the autocorrection is in slot 0 and the typed word
                 // is in slot 1.
-                if (index == mCenterSuggestionIndex
+                if (indexInStrip == mCenterSuggestionIndex
                         && AutoCorrection.shouldBlockAutoCorrectionBySafetyNet(
                                 suggestedWords.getWord(1), suggestedWords.getWord(0))) {
                     return 0xFFFF0000;
@@ -338,67 +343,101 @@
             setupTexts(suggestedWords, countInStrip);
             mMoreSuggestionsAvailable = (suggestedWords.size() > countInStrip);
             int x = 0;
-            for (int index = 0; index < countInStrip; index++) {
-                final int pos = getWordPosition(index, suggestedWords);
-
-                if (index != 0) {
-                    final View divider = mDividers.get(pos);
+            for (int indexInStrip = 0; indexInStrip < countInStrip; indexInStrip++) {
+                if (indexInStrip != 0) {
+                    final View divider = mDividers.get(indexInStrip);
                     // Add divider if this isn't the left most suggestion in suggestions strip.
                     addDivider(stripView, divider);
                     x += divider.getMeasuredWidth();
                 }
 
-                final CharSequence styled = mTexts.get(pos);
-                final TextView word = mWords.get(pos);
-                if (index == mCenterSuggestionIndex && mMoreSuggestionsAvailable) {
-                    // TODO: This "more suggestions hint" should have nicely designed icon.
-                    word.setCompoundDrawablesWithIntrinsicBounds(
-                            null, null, null, mMoreSuggestionsHint);
-                    // HACK: To align with other TextView that has no compound drawables.
-                    word.setCompoundDrawablePadding(-mMoreSuggestionsHint.getIntrinsicHeight());
-                } else {
-                    word.setCompoundDrawablesWithIntrinsicBounds(null, null, null, null);
-                }
-
-                // Disable this suggestion if the suggestion is null or empty.
-                word.setEnabled(!TextUtils.isEmpty(styled));
-                word.setTextColor(getSuggestionTextColor(index, suggestedWords, pos));
-                final int width = getSuggestionWidth(index, stripWidth);
-                final CharSequence text = getEllipsizedText(styled, width, word.getPaint());
-                final float scaleX = word.getTextScaleX();
-                word.setText(text); // TextView.setText() resets text scale x to 1.0.
-                word.setTextScaleX(scaleX);
+                final int width = getSuggestionWidth(indexInStrip, stripWidth);
+                final TextView word = layoutWord(suggestedWords, indexInStrip, width);
                 stripView.addView(word);
-                setLayoutWeight(
-                        word, getSuggestionWeight(index), ViewGroup.LayoutParams.MATCH_PARENT);
+                setLayoutWeight(word, getSuggestionWeight(indexInStrip),
+                        ViewGroup.LayoutParams.MATCH_PARENT);
                 x += word.getMeasuredWidth();
 
-                if (DBG && pos < suggestedWords.size()) {
-                    final String debugInfo = Utils.getDebugInfo(suggestedWords, pos);
-                    if (debugInfo != null) {
-                        final TextView info = mInfos.get(pos);
-                        info.setText(debugInfo);
-                        placer.addView(info);
-                        info.measure(ViewGroup.LayoutParams.WRAP_CONTENT,
-                                ViewGroup.LayoutParams.WRAP_CONTENT);
-                        final int infoWidth = info.getMeasuredWidth();
-                        final int y = info.getMeasuredHeight();
-                        ViewLayoutUtils.placeViewAt(
-                                info, x - infoWidth, y, infoWidth, info.getMeasuredHeight());
-                    }
+                if (DBG) {
+                    layoutDebugInfo(suggestedWords, indexInStrip, placer, x);
                 }
             }
         }
 
-        private int getSuggestionWidth(final int index, final int maxWidth) {
+        /**
+         * Format appropriately the suggested word indirectly specified by
+         * <code>indexInStrip</code> as text in a corresponding {@link TextView}. When the
+         * suggested word doesn't exist, the corresponding {@link TextView} will be disabled
+         * and never respond to user interaction. The suggested word may be shrunk or ellipsized to
+         * fit in the specified width.
+         *
+         * The <code>indexInStrip</code> argument is the index in the suggestion strip. The indices
+         * increase towards the right for LTR scripts and the left for RTL scripts, starting with 0.
+         * The index of the most important suggestion is in {@link #mCenterSuggestionIndex}. This
+         * usually doesn't match the index in <code>suggedtedWords</code> -- see
+         * {@link #getIndexInSuggestedWords(int,SuggestedWords)}.
+         *
+         * @param suggestedWords the list of suggestions.
+         * @param indexInStrip the in the suggestion strip.
+         * @param width the maximum width for layout in pixels.
+         * @return the {@link TextView} containing the suggested word appropriately formatted.
+         */
+        private TextView layoutWord(final SuggestedWords suggestedWords, final int indexInStrip,
+                final int width) {
+            final int indexInSuggestedWords = getIndexInSuggestedWords(
+                    indexInStrip, suggestedWords);
+            final CharSequence styled = mTexts.get(indexInSuggestedWords);
+            final TextView word = mWords.get(indexInSuggestedWords);
+            if (indexInStrip == mCenterSuggestionIndex && mMoreSuggestionsAvailable) {
+                // TODO: This "more suggestions hint" should have a nicely designed icon.
+                word.setCompoundDrawablesWithIntrinsicBounds(
+                        null, null, null, mMoreSuggestionsHint);
+                // HACK: Align with other TextViews that have no compound drawables.
+                word.setCompoundDrawablePadding(-mMoreSuggestionsHint.getIntrinsicHeight());
+            } else {
+                word.setCompoundDrawablesWithIntrinsicBounds(null, null, null, null);
+            }
+
+            // Disable this suggestion if the suggestion is null or empty.
+            word.setEnabled(!TextUtils.isEmpty(styled));
+            word.setTextColor(getSuggestionTextColor(indexInStrip, suggestedWords));
+            final CharSequence text = getEllipsizedText(styled, width, word.getPaint());
+            final float scaleX = word.getTextScaleX();
+            word.setText(text); // TextView.setText() resets text scale x to 1.0.
+            word.setTextScaleX(scaleX);
+            return word;
+        }
+
+        private void layoutDebugInfo(final SuggestedWords suggestedWords, final int indexInStrip,
+                final ViewGroup placer, final int x) {
+            final int indexInSuggestedWords = getIndexInSuggestedWords(
+                    indexInStrip, suggestedWords);
+            if (indexInSuggestedWords >= suggestedWords.size()) {
+                return;
+            }
+            final String debugInfo = Utils.getDebugInfo(suggestedWords, indexInSuggestedWords);
+            if (debugInfo == null) {
+                return;
+            }
+            final TextView info = mInfos.get(indexInSuggestedWords);
+            info.setText(debugInfo);
+            placer.addView(info);
+            info.measure(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
+            final int infoWidth = info.getMeasuredWidth();
+            final int y = info.getMeasuredHeight();
+            ViewLayoutUtils.placeViewAt(
+                    info, x - infoWidth, y, infoWidth, info.getMeasuredHeight());
+        }
+
+        private int getSuggestionWidth(final int indexInStrip, final int maxWidth) {
             final int paddings = mPadding * mSuggestionsCountInStrip;
             final int dividers = mDividerWidth * (mSuggestionsCountInStrip - 1);
             final int availableWidth = maxWidth - paddings - dividers;
-            return (int)(availableWidth * getSuggestionWeight(index));
+            return (int)(availableWidth * getSuggestionWeight(indexInStrip));
         }
 
-        private float getSuggestionWeight(final int index) {
-            if (index == mCenterSuggestionIndex) {
+        private float getSuggestionWeight(final int indexInStrip) {
+            if (indexInStrip == mCenterSuggestionIndex) {
                 return mCenterSuggestionWeight;
             } else {
                 // TODO: Revisit this for cases of 5 or more suggestions
@@ -422,16 +461,16 @@
         private void layoutPunctuationSuggestions(final SuggestedWords suggestedWords,
                 final ViewGroup stripView) {
             final int countInStrip = Math.min(suggestedWords.size(), PUNCTUATIONS_IN_STRIP);
-            for (int index = 0; index < countInStrip; index++) {
-                if (index != 0) {
+            for (int indexInStrip = 0; indexInStrip < countInStrip; indexInStrip++) {
+                if (indexInStrip != 0) {
                     // Add divider if this isn't the left most suggestion in suggestions strip.
-                    addDivider(stripView, mDividers.get(index));
+                    addDivider(stripView, mDividers.get(indexInStrip));
                 }
 
-                final TextView word = mWords.get(index);
+                final TextView word = mWords.get(indexInStrip);
                 word.setEnabled(true);
                 word.setTextColor(mColorAutoCorrect);
-                final String text = suggestedWords.getWord(index);
+                final String text = suggestedWords.getWord(indexInStrip);
                 word.setText(text);
                 word.setTextScaleX(1.0f);
                 word.setCompoundDrawables(null, null, null, null);
diff --git a/java/src/com/android/inputmethod/research/LogUnit.java b/java/src/com/android/inputmethod/research/LogUnit.java
index cf1388f..164c7e8 100644
--- a/java/src/com/android/inputmethod/research/LogUnit.java
+++ b/java/src/com/android/inputmethod/research/LogUnit.java
@@ -67,7 +67,7 @@
     private String[] mWordArray = EMPTY_STRING_ARRAY;
     private boolean mMayContainDigit;
     private boolean mIsPartOfMegaword;
-    private boolean mContainsCorrection;
+    private boolean mContainsUserDeletions;
 
     // mCorrectionType indicates whether the word was corrected at all, and if so, the nature of the
     // correction.
@@ -277,13 +277,13 @@
     }
 
     // TODO: Refactor to eliminate getter/setters
-    public void setContainsCorrection() {
-        mContainsCorrection = true;
+    public void setContainsUserDeletions() {
+        mContainsUserDeletions = true;
     }
 
     // TODO: Refactor to eliminate getter/setters
-    public boolean containsCorrection() {
-        return mContainsCorrection;
+    public boolean containsUserDeletions() {
+        return mContainsUserDeletions;
     }
 
     // TODO: Refactor to eliminate getter/setters
@@ -323,7 +323,7 @@
                         true /* isPartOfMegaword */);
                 newLogUnit.mWords = null;
                 newLogUnit.mMayContainDigit = mMayContainDigit;
-                newLogUnit.mContainsCorrection = mContainsCorrection;
+                newLogUnit.mContainsUserDeletions = mContainsUserDeletions;
 
                 // Purge the logStatements and associated data from this LogUnit.
                 laterLogStatements.clear();
@@ -346,7 +346,7 @@
             setWords(logUnit.mWords);
         }
         mMayContainDigit = mMayContainDigit || logUnit.mMayContainDigit;
-        mContainsCorrection = mContainsCorrection || logUnit.mContainsCorrection;
+        mContainsUserDeletions = mContainsUserDeletions || logUnit.mContainsUserDeletions;
         mIsPartOfMegaword = false;
     }
 
diff --git a/java/src/com/android/inputmethod/research/ResearchLogger.java b/java/src/com/android/inputmethod/research/ResearchLogger.java
index 64f0349..56ab90c 100644
--- a/java/src/com/android/inputmethod/research/ResearchLogger.java
+++ b/java/src/com/android/inputmethod/research/ResearchLogger.java
@@ -260,14 +260,14 @@
                     if (DEBUG) {
                         final String wordsString = logUnit.getWordsAsString();
                         Log.d(TAG, "onPublish: '" + wordsString
-                                + "', hc: " + logUnit.containsCorrection()
+                                + "', hc: " + logUnit.containsUserDeletions()
                                 + ", cipd: " + canIncludePrivateData);
                     }
                     for (final String word : logUnit.getWordsAsStringArray()) {
                         final Dictionary dictionary = getDictionary();
                         mStatistics.recordWordEntered(
                                 dictionary != null && dictionary.isValidWord(word),
-                                logUnit.containsCorrection());
+                                logUnit.containsUserDeletions());
                     }
                 }
                 publishLogUnits(logUnits, mMainResearchLog, canIncludePrivateData);
@@ -819,8 +819,8 @@
         mCurrentLogUnit.setMayContainDigit();
     }
 
-    private void setCurrentLogUnitContainsCorrection() {
-        mCurrentLogUnit.setContainsCorrection();
+    private void setCurrentLogUnitContainsUserDeletions() {
+        mCurrentLogUnit.setContainsUserDeletions();
     }
 
     private void setCurrentLogUnitCorrectionType(final int correctionType) {
@@ -920,7 +920,7 @@
             if (DEBUG) {
                 Log.d(TAG, "publishLogBuffer: " + (logUnit.hasOneOrMoreWords()
                         ? logUnit.getWordsAsString() : "<wordless>")
-                        + ", correction?: " + logUnit.containsCorrection());
+                        + ", correction?: " + logUnit.containsUserDeletions());
             }
             researchLog.publish(logUnit, canIncludePrivateData);
         }
@@ -1286,7 +1286,7 @@
         final ResearchLogger researchLogger = getInstance();
         if (!replacedWord.equals(suggestion.toString())) {
             // The user chose something other than what was already there.
-            researchLogger.setCurrentLogUnitContainsCorrection();
+            researchLogger.setCurrentLogUnitContainsUserDeletions();
             researchLogger.setCurrentLogUnitCorrectionType(LogUnit.CORRECTIONTYPE_TYPO);
         }
         final String scrubbedWord = scrubDigitsFromString(suggestion);
@@ -1463,7 +1463,7 @@
                 LOGSTATEMENT_LATINIME_REVERTCOMMIT, committedWord, originallyTypedWord,
                 separatorString);
         if (logUnit != null) {
-            logUnit.setContainsCorrection();
+            logUnit.setContainsUserDeletions();
         }
         researchLogger.mStatistics.recordRevertCommit(SystemClock.uptimeMillis());
     }
@@ -1618,25 +1618,6 @@
     }
 
     private boolean isExpectingCommitText = false;
-    /**
-     * Log a call to (UnknownClass).commitPartialText
-     *
-     * SystemResponse: The IME is committing part of a word.  This happens if a space is
-     * automatically inserted to split a single typed string into two or more words.
-     */
-    // TODO: This method is currently unused.  Find where it should be called from in the IME and
-    // add invocations.
-    private static final LogStatement LOGSTATEMENT_COMMIT_PARTIAL_TEXT =
-            new LogStatement("CommitPartialText", true, false, "newCursorPosition");
-    public static void commitPartialText(final String committedWord,
-            final long lastTimestampOfWordData, final boolean isBatchMode) {
-        final ResearchLogger researchLogger = getInstance();
-        final String scrubbedWord = scrubDigitsFromString(committedWord);
-        researchLogger.enqueueEvent(LOGSTATEMENT_COMMIT_PARTIAL_TEXT);
-        researchLogger.mStatistics.recordAutoCorrection(SystemClock.uptimeMillis());
-        researchLogger.commitCurrentLogUnitAsWord(scrubbedWord, lastTimestampOfWordData,
-                isBatchMode);
-    }
 
     /**
      * Log a call to RichInputConnection.commitText().
diff --git a/native/jni/src/dictionary.h b/native/jni/src/dictionary.h
index 2ad5b6c..edec83f 100644
--- a/native/jni/src/dictionary.h
+++ b/native/jni/src/dictionary.h
@@ -41,6 +41,10 @@
     static const int KIND_APP_DEFINED = 6; // Suggested by the application
     static const int KIND_SHORTCUT = 7; // A shortcut
     static const int KIND_PREDICTION = 8; // A prediction (== a suggestion with no input)
+    // KIND_RESUMED: A resumed suggestion (comes from a span, currently this type is used only
+    // in java for re-correction)
+    static const int KIND_RESUMED = 9;
+    static const int KIND_OOV_CORRECTION = 10; // Most probable string correction
 
     static const int KIND_MASK_FLAGS = 0xFFFFFF00; // Mask to get the flags
     static const int KIND_FLAG_POSSIBLY_OFFENSIVE = 0x80000000;
diff --git a/tests/src/com/android/inputmethod/keyboard/internal/KeySpecParserCsvTests.java b/tests/src/com/android/inputmethod/keyboard/internal/KeySpecParserSplitTests.java
similarity index 91%
rename from tests/src/com/android/inputmethod/keyboard/internal/KeySpecParserCsvTests.java
rename to tests/src/com/android/inputmethod/keyboard/internal/KeySpecParserSplitTests.java
index 9014e7c..eea1efc 100644
--- a/tests/src/com/android/inputmethod/keyboard/internal/KeySpecParserCsvTests.java
+++ b/tests/src/com/android/inputmethod/keyboard/internal/KeySpecParserSplitTests.java
@@ -17,11 +17,13 @@
 package com.android.inputmethod.keyboard.internal;
 
 import android.app.Instrumentation;
+import android.content.Context;
+import android.content.res.Resources;
 import android.test.InstrumentationTestCase;
 import android.test.suitebuilder.annotation.MediumTest;
 
 import com.android.inputmethod.latin.CollectionUtils;
-import com.android.inputmethod.latin.StringUtils;
+import com.android.inputmethod.latin.LocaleUtils.RunInLocale;
 
 import java.lang.reflect.Field;
 import java.util.ArrayList;
@@ -29,16 +31,24 @@
 import java.util.Locale;
 
 @MediumTest
-public class KeySpecParserCsvTests extends InstrumentationTestCase {
-    private final KeyboardTextsSet mTextsSet = new KeyboardTextsSet();
+public class KeySpecParserSplitTests extends InstrumentationTestCase {
+    private static final Locale TEST_LOCALE = Locale.ENGLISH;
+    final KeyboardTextsSet mTextsSet = new KeyboardTextsSet();
 
     @Override
     protected void setUp() throws Exception {
         super.setUp();
 
         final Instrumentation instrumentation = getInstrumentation();
-        mTextsSet.setLanguage(Locale.ENGLISH.getLanguage());
-        mTextsSet.loadStringResources(instrumentation.getTargetContext());
+        final Context targetContext = instrumentation.getTargetContext();
+        mTextsSet.setLanguage(TEST_LOCALE.getLanguage());
+        new RunInLocale<Void>() {
+            @Override
+            protected Void job(final Resources res) {
+                mTextsSet.loadStringResources(targetContext);
+                return null;
+            }
+        }.runInLocale(targetContext.getResources(), TEST_LOCALE);
         final String[] testResourceNames = getAllResourceIdNames(
                 com.android.inputmethod.latin.tests.R.string.class);
         mTextsSet.loadStringResourcesInternal(instrumentation.getContext(),
@@ -56,8 +66,8 @@
         return names.toArray(new String[names.size()]);
     }
 
-    private static void assertArrayEquals(final String message, final Object[] expected,
-            final Object[] actual) {
+    private static <T> void assertArrayEquals(final String message, final T[] expected,
+            final T[] actual) {
         if (expected == actual) {
             return;
         }
@@ -70,15 +80,19 @@
             return;
         }
         for (int i = 0; i < expected.length; i++) {
-            assertEquals(message + " [" + i + "]",
-                    Arrays.toString(expected), Arrays.toString(actual));
+            final T e = expected[i];
+            final T a = actual[i];
+            if (e == a) {
+                continue;
+            }
+            assertEquals(message + " [" + i + "]", e, a);
         }
     }
 
     private void assertTextArray(final String message, final String value,
             final String ... expectedArray) {
         final String resolvedActual = KeySpecParser.resolveTextReference(value, mTextsSet);
-        final String[] actual = StringUtils.parseCsvString(resolvedActual);
+        final String[] actual = KeySpecParser.splitKeySpecs(resolvedActual);
         final String[] expected = (expectedArray.length == 0) ? null : expectedArray;
         assertArrayEquals(message, expected, actual);
     }
@@ -101,7 +115,7 @@
     private static final String SURROGATE1 = PAIR1 + PAIR2;
     private static final String SURROGATE2 = PAIR1 + PAIR2 + PAIR3;
 
-    public void testParseCsvTextZero() {
+    public void testSplitZero() {
         assertTextArray("Empty string", "");
         assertTextArray("Empty entry", ",");
         assertTextArray("Empty entry at beginning", ",a", "a");
@@ -110,7 +124,7 @@
         assertTextArray("Empty entries with escape", ",a,b\\,c,,d,", "a", "b\\,c", "d");
     }
 
-    public void testParseCsvTextSingle() {
+    public void testSplitSingle() {
         assertTextArray("Single char", "a", "a");
         assertTextArray("Surrogate pair", PAIR1, PAIR1);
         assertTextArray("Single escape", "\\", "\\");
@@ -139,7 +153,7 @@
         assertTextArray("Incomplete resource reference 4", "!" + SURROGATE2, "!" + SURROGATE2);
     }
 
-    public void testParseCsvTextSingleEscaped() {
+    public void testSplitSingleEscaped() {
         assertTextArray("Escaped char", "\\a", "\\a");
         assertTextArray("Escaped surrogate pair", "\\" + PAIR1, "\\" + PAIR1);
         assertTextArray("Escaped comma", "\\,", "\\,");
@@ -174,7 +188,7 @@
         assertTextArray("Escaped !TEXT/NAME", "\\!TEXT/EMPTY_STRING", "\\!TEXT/EMPTY_STRING");
     }
 
-    public void testParseCsvTextMulti() {
+    public void testSplitMulti() {
         assertTextArray("Multiple chars", "a,b,c", "a", "b", "c");
         assertTextArray("Multiple chars", "a,b,\\c", "a", "b", "\\c");
         assertTextArray("Multiple chars and escape at beginning and end",
@@ -189,7 +203,7 @@
                 " abc ", " def ", " ghi ");
     }
 
-    public void testParseCsvTextMultiEscaped() {
+    public void testSplitMultiEscaped() {
         assertTextArray("Multiple chars with comma", "a,\\,,c", "a", "\\,", "c");
         assertTextArray("Multiple chars with comma surrounded by spaces", " a , \\, , c ",
                 " a ", " \\, ", " c ");
@@ -208,17 +222,17 @@
                 "\\!", "\\!TEXT/EMPTY_STRING");
     }
 
-    public void testParseCsvResourceError() {
+    public void testSplitResourceError() {
         assertError("Incomplete resource name", "!text/", "!text/");
         assertError("Non existing resource", "!text/non_existing");
     }
 
-    public void testParseCsvResourceZero() {
+    public void testSplitResourceZero() {
         assertTextArray("Empty string",
                 "!text/empty_string");
     }
 
-    public void testParseCsvResourceSingle() {
+    public void testSplitResourceSingle() {
         assertTextArray("Single char",
                 "!text/single_char", "a");
         assertTextArray("Space",
@@ -240,7 +254,7 @@
                 "\\\\!text/single_char", "\\\\a");
     }
 
-    public void testParseCsvResourceSingleEscaped() {
+    public void testSplitResourceSingleEscaped() {
         assertTextArray("Escaped char",
                 "!text/escaped_char", "\\a");
         assertTextArray("Escaped comma",
@@ -267,7 +281,7 @@
                 "!text/escaped_label_with_escape", "a\\\\c");
     }
 
-    public void testParseCsvResourceMulti() {
+    public void testSplitResourceMulti() {
         assertTextArray("Multiple chars",
                 "!text/multiple_chars", "a", "b", "c");
         assertTextArray("Multiple chars surrounded by spaces",
@@ -279,7 +293,7 @@
                 "!text/multiple_labels_surrounded_by_spaces", " abc ", " def ", " ghi ");
     }
 
-    public void testParseCsvResourcetMultiEscaped() {
+    public void testSplitResourcetMultiEscaped() {
         assertTextArray("Multiple chars with comma",
                 "!text/multiple_chars_with_comma",
                 "a", "\\,", "c");
@@ -300,7 +314,7 @@
                 " ab\\\\ ", " d\\\\\\, ", " g\\,i ");
     }
 
-    public void testParseMultipleResources() {
+    public void testSplitMultipleResources() {
         assertTextArray("Literals and resources",
                 "1,!text/multiple_chars,z", "1", "a", "b", "c", "z");
         assertTextArray("Literals and resources and escape at end",
@@ -322,7 +336,7 @@
                 "abcabc", "def", "ghi");
     }
 
-    public void testParseIndirectReference() {
+    public void testSplitIndirectReference() {
         assertTextArray("Indirect",
                 "!text/indirect_string", "a", "b", "c");
         assertTextArray("Indirect with literal",
@@ -331,7 +345,7 @@
                 "!text/indirect2_string", "a", "b", "c");
     }
 
-    public void testParseInfiniteIndirectReference() {
+    public void testSplitInfiniteIndirectReference() {
         assertError("Infinite indirection",
                 "1,!text/infinite_indirection,2", "1", "infinite", "<infinite>", "loop", "2");
     }
diff --git a/tests/src/com/android/inputmethod/keyboard/internal/KeySpecParserTests.java b/tests/src/com/android/inputmethod/keyboard/internal/KeySpecParserTests.java
index 861abe8..b55158d 100644
--- a/tests/src/com/android/inputmethod/keyboard/internal/KeySpecParserTests.java
+++ b/tests/src/com/android/inputmethod/keyboard/internal/KeySpecParserTests.java
@@ -20,18 +20,22 @@
 import static com.android.inputmethod.latin.Constants.CODE_OUTPUT_TEXT;
 import static com.android.inputmethod.latin.Constants.CODE_UNSPECIFIED;
 
+import android.content.Context;
+import android.content.res.Resources;
 import android.test.AndroidTestCase;
 import android.test.suitebuilder.annotation.SmallTest;
 
 import com.android.inputmethod.latin.Constants;
+import com.android.inputmethod.latin.LocaleUtils.RunInLocale;
 
 import java.util.Arrays;
 import java.util.Locale;
 
 @SmallTest
 public class KeySpecParserTests extends AndroidTestCase {
-    private final KeyboardCodesSet mCodesSet = new KeyboardCodesSet();
-    private final KeyboardTextsSet mTextsSet = new KeyboardTextsSet();
+    private final static Locale TEST_LOCALE = Locale.ENGLISH;
+    final KeyboardCodesSet mCodesSet = new KeyboardCodesSet();
+    final KeyboardTextsSet mTextsSet = new KeyboardTextsSet();
 
     private static final String CODE_SETTINGS = "!code/key_settings";
     private static final String ICON_SETTINGS = "!icon/settings_key";
@@ -48,10 +52,17 @@
     protected void setUp() throws Exception {
         super.setUp();
 
-        final String language = Locale.ENGLISH.getLanguage();
+        final String language = TEST_LOCALE.getLanguage();
         mCodesSet.setLanguage(language);
         mTextsSet.setLanguage(language);
-        mTextsSet.loadStringResources(getContext());
+        final Context context = getContext();
+        new RunInLocale<Void>() {
+            @Override
+            protected Void job(final Resources res) {
+                mTextsSet.loadStringResources(context);
+                return null;
+            }
+        }.runInLocale(context.getResources(), TEST_LOCALE);
 
         mCodeSettings = KeySpecParser.parseCode(
                 CODE_SETTINGS, mCodesSet, CODE_UNSPECIFIED);
diff --git a/tests/src/com/android/inputmethod/keyboard/internal/MatrixUtilsTests.java b/tests/src/com/android/inputmethod/keyboard/internal/MatrixUtilsTests.java
new file mode 100644
index 0000000..e2a11ab
--- /dev/null
+++ b/tests/src/com/android/inputmethod/keyboard/internal/MatrixUtilsTests.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2013 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.keyboard.internal;
+
+import com.android.inputmethod.keyboard.internal.MatrixUtils.MatrixOperationFailedException;
+
+import android.test.AndroidTestCase;
+import android.test.suitebuilder.annotation.SmallTest;
+
+@SmallTest
+public class MatrixUtilsTests extends AndroidTestCase {
+    // "run tests" -c com.android.inputmethod.keyboard.internal.MatrixUtilsTests
+    private static final boolean DEBUG = false;
+    private static final float EPSILON = 0.00001f;
+
+    private static void assertEqualsFloat(float f0, float f1) {
+        assertEqualsFloat(f0, f1, EPSILON);
+    }
+
+    /* package */ static void assertEqualsFloat(float f0, float f1, float error) {
+        assertTrue(Math.abs(f0 - f1) < error);
+    }
+
+    public void testMulti() {
+        final float[][] matrixA = {{1, 2}, {3, 4}};
+        final float[][] matrixB = {{5, 6}, {7, 8}};
+        final float[][] retval = new float[2][2];
+        try {
+            MatrixUtils.multiply(matrixA, matrixB, retval);
+        } catch (MatrixOperationFailedException e) {
+            assertTrue(false);
+        }
+        if (DEBUG) {
+            MatrixUtils.dump("multi", retval);
+        }
+        assertEqualsFloat(retval[0][0], 19);
+        assertEqualsFloat(retval[0][1], 22);
+        assertEqualsFloat(retval[1][0], 43);
+        assertEqualsFloat(retval[1][1], 50);
+    }
+
+    public void testInverse() {
+        final int N = 4;
+        final float[][] matrix =
+                {{1, 2, 3, 4}, {4, 0, 5, 6}, {6, 4, 2, 0}, {6, 4, 2, 1}};
+        final float[][] inverse = new float[N][N];
+        final float[][] tempMatrix = new float[N][N];
+        for (int i = 0; i < N; ++i) {
+            for (int j = 0; j < N; ++j) {
+                tempMatrix[i][j] = matrix[i][j];
+            }
+        }
+        final float[][] retval = new float[N][N];
+        try {
+            MatrixUtils.inverse(tempMatrix, inverse);
+        } catch (MatrixOperationFailedException e) {
+            assertTrue(false);
+        }
+        try {
+            MatrixUtils.multiply(matrix, inverse, retval);
+        } catch (MatrixOperationFailedException e) {
+            assertTrue(false);
+        }
+        for (int i = 0; i < N; ++i) {
+            for (int j = 0; j < N; ++j) {
+                assertEqualsFloat(((i == j) ? 1.0f : 0.0f), retval[i][j]);
+            }
+        }
+    }
+}
diff --git a/tests/src/com/android/inputmethod/keyboard/internal/SmoothingUtilsTests.java b/tests/src/com/android/inputmethod/keyboard/internal/SmoothingUtilsTests.java
new file mode 100644
index 0000000..293741a
--- /dev/null
+++ b/tests/src/com/android/inputmethod/keyboard/internal/SmoothingUtilsTests.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2013 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.keyboard.internal;
+
+import com.android.inputmethod.keyboard.internal.MatrixUtils.MatrixOperationFailedException;
+
+import android.test.AndroidTestCase;
+import android.test.suitebuilder.annotation.SmallTest;
+
+@SmallTest
+public class SmoothingUtilsTests extends AndroidTestCase {
+    // "run tests" -c com.android.inputmethod.keyboard.internal.SmoothingUtilsTests
+    private static final boolean DEBUG = false;
+
+    public void testGet3DParamaters() {
+        final float[] xs = new float[] {0, 1, 2, 3, 4};
+        final float[] ys = new float[] {1, 4, 15, 40, 85}; // y = x^3 + x^2 + x + 1
+        final float[][] retval = new float[4][1];
+        try {
+            SmoothingUtils.get3DParameters(xs, ys, retval);
+            if (DEBUG) {
+                MatrixUtils.dump("3d", retval);
+            }
+            for (int i = 0; i < 4; ++i) {
+                MatrixUtilsTests.assertEqualsFloat(retval[i][0], 1.0f, 0.001f);
+            }
+        } catch (MatrixOperationFailedException e) {
+            assertTrue(false);
+        }
+    }
+}
diff --git a/tests/src/com/android/inputmethod/latin/InputPointersTests.java b/tests/src/com/android/inputmethod/latin/InputPointersTests.java
index e1149b3..3015829 100644
--- a/tests/src/com/android/inputmethod/latin/InputPointersTests.java
+++ b/tests/src/com/android/inputmethod/latin/InputPointersTests.java
@@ -108,13 +108,13 @@
         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",
+        assertIntArrayEquals("xCoordinates values after copy",
                 dst.getXCoordinates(), 0, src.getXCoordinates(), 0, size);
-        assertArrayEquals("yCoordinates values after copy",
+        assertIntArrayEquals("yCoordinates values after copy",
                 dst.getYCoordinates(), 0, src.getYCoordinates(), 0, size);
-        assertArrayEquals("pointerIds values after copy",
+        assertIntArrayEquals("pointerIds values after copy",
                 dst.getPointerIds(), 0, src.getPointerIds(), 0, size);
-        assertArrayEquals("times values after copy",
+        assertIntArrayEquals("times values after copy",
                 dst.getTimes(), 0, src.getTimes(), 0, size);
     }
 
@@ -135,34 +135,34 @@
 
         dst.append(src, 0, 0);
         assertEquals("size after append zero", dstLen, dst.getPointerSize());
-        assertArrayEquals("xCoordinates after append zero",
+        assertIntArrayEquals("xCoordinates after append zero",
                 dstCopy.getXCoordinates(), 0, dst.getXCoordinates(), 0, dstLen);
-        assertArrayEquals("yCoordinates after append zero",
+        assertIntArrayEquals("yCoordinates after append zero",
                 dstCopy.getYCoordinates(), 0, dst.getYCoordinates(), 0, dstLen);
-        assertArrayEquals("pointerIds after append zero",
+        assertIntArrayEquals("pointerIds after append zero",
                 dstCopy.getPointerIds(), 0, dst.getPointerIds(), 0, dstLen);
-        assertArrayEquals("times after append zero",
+        assertIntArrayEquals("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",
+        assertIntArrayEquals("original xCoordinates values after append",
                 dstCopy.getXCoordinates(), 0, dst.getXCoordinates(), 0, dstLen);
-        assertArrayEquals("original yCoordinates values after append",
+        assertIntArrayEquals("original yCoordinates values after append",
                 dstCopy.getYCoordinates(), 0, dst.getYCoordinates(), 0, dstLen);
-        assertArrayEquals("original pointerIds values after append",
+        assertIntArrayEquals("original pointerIds values after append",
                 dstCopy.getPointerIds(), 0, dst.getPointerIds(), 0, dstLen);
-        assertArrayEquals("original times values after append",
+        assertIntArrayEquals("original times values after append",
                 dstCopy.getTimes(), 0, dst.getTimes(), 0, dstLen);
-        assertArrayEquals("appended xCoordinates values after append",
+        assertIntArrayEquals("appended xCoordinates values after append",
                 src.getXCoordinates(), 0, dst.getXCoordinates(), dstLen, srcLen);
-        assertArrayEquals("appended yCoordinates values after append",
+        assertIntArrayEquals("appended yCoordinates values after append",
                 src.getYCoordinates(), 0, dst.getYCoordinates(), dstLen, srcLen);
-        assertArrayEquals("appended pointerIds values after append",
+        assertIntArrayEquals("appended pointerIds values after append",
                 src.getPointerIds(), 0, dst.getPointerIds(), dstLen, srcLen);
-        assertArrayEquals("appended times values after append",
+        assertIntArrayEquals("appended times values after append",
                 src.getTimes(), 0, dst.getTimes(), dstLen, srcLen);
     }
 
@@ -190,47 +190,55 @@
 
         dst.append(srcPointerId, srcTimes, srcXCoords, srcYCoords, 0, 0);
         assertEquals("size after append zero", dstLen, dst.getPointerSize());
-        assertArrayEquals("xCoordinates after append zero",
+        assertIntArrayEquals("xCoordinates after append zero",
                 dstCopy.getXCoordinates(), 0, dst.getXCoordinates(), 0, dstLen);
-        assertArrayEquals("yCoordinates after append zero",
+        assertIntArrayEquals("yCoordinates after append zero",
                 dstCopy.getYCoordinates(), 0, dst.getYCoordinates(), 0, dstLen);
-        assertArrayEquals("pointerIds after append zero",
+        assertIntArrayEquals("pointerIds after append zero",
                 dstCopy.getPointerIds(), 0, dst.getPointerIds(), 0, dstLen);
-        assertArrayEquals("times after append zero",
+        assertIntArrayEquals("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",
+        assertIntArrayEquals("original xCoordinates values after append",
                 dstCopy.getXCoordinates(), 0, dst.getXCoordinates(), 0, dstLen);
-        assertArrayEquals("original yCoordinates values after append",
+        assertIntArrayEquals("original yCoordinates values after append",
                 dstCopy.getYCoordinates(), 0, dst.getYCoordinates(), 0, dstLen);
-        assertArrayEquals("original pointerIds values after append",
+        assertIntArrayEquals("original pointerIds values after append",
                 dstCopy.getPointerIds(), 0, dst.getPointerIds(), 0, dstLen);
-        assertArrayEquals("original times values after append",
+        assertIntArrayEquals("original times values after append",
                 dstCopy.getTimes(), 0, dst.getTimes(), 0, dstLen);
-        assertArrayEquals("appended xCoordinates values after append",
+        assertIntArrayEquals("appended xCoordinates values after append",
                 srcXCoords.getPrimitiveArray(), 0, dst.getXCoordinates(), dstLen, srcLen);
-        assertArrayEquals("appended yCoordinates values after append",
+        assertIntArrayEquals("appended yCoordinates values after append",
                 srcYCoords.getPrimitiveArray(), 0, dst.getYCoordinates(), dstLen, srcLen);
-        assertArrayEquals("appended pointerIds values after append",
+        assertIntArrayEquals("appended pointerIds values after append",
                 srcPointerIds, 0, dst.getPointerIds(), dstLen, srcLen);
-        assertArrayEquals("appended times values after append",
+        assertIntArrayEquals("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) {
+    // TODO: Consolidate this method with
+    // {@link ResizableIntArrayTests#assertIntArrayEquals(String,int[],int,int[],int,int)}.
+    private static void assertIntArrayEquals(final String message, final int[] expecteds,
+            final int expectedPos, final int[] actuals, final int actualPos, final int length) {
+        if (expecteds == actuals) {
             return;
         }
         if (expecteds == null || actuals == null) {
-            fail(message + ": expecteds=" + expecteds + " actuals=" + actuals);
+            assertEquals(message, Arrays.toString(expecteds), Arrays.toString(actuals));
+            return;
+        }
+        if (expecteds.length < expectedPos + length || actuals.length < actualPos + length) {
+            fail(message + ": insufficient length: expecteds=" + Arrays.toString(expecteds)
+                    + " actuals=" + Arrays.toString(actuals));
+            return;
         }
         for (int i = 0; i < length; i++) {
-            assertEquals(message + ": element at " + i,
+            assertEquals(message + " [" + i + "]",
                     expecteds[i + expectedPos], actuals[i + actualPos]);
         }
     }
diff --git a/tests/src/com/android/inputmethod/latin/ResizableIntArrayTests.java b/tests/src/com/android/inputmethod/latin/ResizableIntArrayTests.java
index 2d1b836..b9fee95 100644
--- a/tests/src/com/android/inputmethod/latin/ResizableIntArrayTests.java
+++ b/tests/src/com/android/inputmethod/latin/ResizableIntArrayTests.java
@@ -19,6 +19,8 @@
 import android.test.AndroidTestCase;
 import android.test.suitebuilder.annotation.SmallTest;
 
+import java.util.Arrays;
+
 @SmallTest
 public class ResizableIntArrayTests extends AndroidTestCase {
     private static final int DEFAULT_CAPACITY = 48;
@@ -186,7 +188,7 @@
         assertEquals("length after copy", dst.getLength(), src.getLength());
         assertSame("array after copy", array, dst.getPrimitiveArray());
         assertNotSame("array after copy", dst.getPrimitiveArray(), src.getPrimitiveArray());
-        assertArrayEquals("values after copy",
+        assertIntArrayEquals("values after copy",
                 dst.getPrimitiveArray(), 0, src.getPrimitiveArray(), 0, dst.getLength());
 
         final int smallerLength = DEFAULT_CAPACITY / 2;
@@ -197,7 +199,7 @@
         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",
+        assertIntArrayEquals("values after copy to smaller",
                 dst.getPrimitiveArray(), 0, src.getPrimitiveArray(), 0, dst.getLength());
     }
 
@@ -220,7 +222,7 @@
         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",
+        assertIntArrayEquals("values after append zero",
                 dstCopy.getPrimitiveArray(), 0, dst.getPrimitiveArray(), 0, dstLen);
 
         dst.append(src, 0, srcLen);
@@ -228,9 +230,9 @@
         assertSame("array after append", array, dst.getPrimitiveArray());
         assertTrue("primitive length after append",
                 dst.getPrimitiveArray().length >= dstLen + srcLen);
-        assertArrayEquals("original values after append",
+        assertIntArrayEquals("original values after append",
                 dstCopy.getPrimitiveArray(), 0, dst.getPrimitiveArray(), 0, dstLen);
-        assertArrayEquals("appended values after append",
+        assertIntArrayEquals("appended values after append",
                 src.getPrimitiveArray(), 0, dst.getPrimitiveArray(), dstLen, srcLen);
 
         dst.append(src, 0, srcLen);
@@ -238,11 +240,11 @@
         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",
+        assertIntArrayEquals("original values after 2nd append",
                 dstCopy.getPrimitiveArray(), 0, dst.getPrimitiveArray(), 0, dstLen);
-        assertArrayEquals("appended values after 2nd append",
+        assertIntArrayEquals("appended values after 2nd append",
                 src.getPrimitiveArray(), 0, dst.getPrimitiveArray(), dstLen, srcLen);
-        assertArrayEquals("appended values after 2nd append",
+        assertIntArrayEquals("appended values after 2nd append",
                 src.getPrimitiveArray(), 0, dst.getPrimitiveArray(), dstLen + srcLen, srcLen);
     }
 
@@ -319,16 +321,22 @@
         }
     }
 
-    private static void assertArrayEquals(String message, int[] expecteds, int expectedPos,
-            int[] actuals, int actualPos, int length) {
-        if (expecteds == null && actuals == null) {
+    private static void assertIntArrayEquals(final String message, final int[] expecteds,
+            final int expectedPos, final int[] actuals, final int actualPos, final int length) {
+        if (expecteds == actuals) {
             return;
         }
         if (expecteds == null || actuals == null) {
-            fail(message + ": expecteds=" + expecteds + " actuals=" + actuals);
+            assertEquals(message, Arrays.toString(expecteds), Arrays.toString(actuals));
+            return;
+        }
+        if (expecteds.length < expectedPos + length || actuals.length < actualPos + length) {
+            fail(message + ": insufficient length: expecteds=" + Arrays.toString(expecteds)
+                    + " actuals=" + Arrays.toString(actuals));
+            return;
         }
         for (int i = 0; i < length; i++) {
-            assertEquals(message + ": element at " + i,
+            assertEquals(message + " [" + i + "]",
                     expecteds[i + expectedPos], actuals[i + actualPos]);
         }
     }
diff --git a/tests/src/com/android/inputmethod/latin/ResourceUtilsTests.java b/tests/src/com/android/inputmethod/latin/ResourceUtilsTests.java
index ed16846..c915522 100644
--- a/tests/src/com/android/inputmethod/latin/ResourceUtilsTests.java
+++ b/tests/src/com/android/inputmethod/latin/ResourceUtilsTests.java
@@ -19,25 +19,41 @@
 import android.test.AndroidTestCase;
 import android.test.suitebuilder.annotation.SmallTest;
 
+import com.android.inputmethod.latin.ResourceUtils.DeviceOverridePatternSyntaxError;
+
 import java.util.HashMap;
 
 @SmallTest
 public class ResourceUtilsTests extends AndroidTestCase {
     public void testFindDefaultConstant() {
         final String[] nullArray = null;
-        assertNull(ResourceUtils.findDefaultConstant(nullArray));
-
         final String[] emptyArray = {};
-        assertNull(ResourceUtils.findDefaultConstant(emptyArray));
-
         final String[] array = {
-            "HARDWARE=grouper,0.3",
-            "HARDWARE=mako,0.4",
-            ",defaultValue1",
-            "HARDWARE=manta,0.2",
-            ",defaultValue2",
+                "HARDWARE=grouper,0.3",
+                "HARDWARE=mako,0.4",
+                ",defaultValue1",
+                "HARDWARE=manta,0.2",
+                ",defaultValue2",
         };
-        assertEquals(ResourceUtils.findDefaultConstant(array), "defaultValue1");
+
+        try {
+            assertNull(ResourceUtils.findDefaultConstant(nullArray));
+            assertNull(ResourceUtils.findDefaultConstant(emptyArray));
+            assertEquals(ResourceUtils.findDefaultConstant(array), "defaultValue1");
+        } catch (final DeviceOverridePatternSyntaxError e) {
+            fail(e.getMessage());
+        }
+
+        final String[] errorArray = {
+            "HARDWARE=grouper,0.3",
+            "no_comma"
+        };
+        try {
+            final String defaultValue = ResourceUtils.findDefaultConstant(errorArray);
+            fail("exception should be thrown: defaultValue=" + defaultValue);
+        } catch (final DeviceOverridePatternSyntaxError e) {
+            assertEquals("Array element has no comma: no_comma", e.getMessage());
+        }
     }
 
     public void testFindConstantForKeyValuePairsSimple() {
@@ -67,33 +83,23 @@
 
         final HashMap<String,String> keyValues = CollectionUtils.newHashMap();
         keyValues.put(HARDWARE_KEY, "grouper");
-        assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.3");
+        assertEquals("0.3", ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
         keyValues.put(HARDWARE_KEY, "mako");
-        assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.4");
+        assertEquals("0.4", ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
         keyValues.put(HARDWARE_KEY, "manta");
-        assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.2");
+        assertEquals("0.2", ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
 
-        try {
-            keyValues.clear();
-            keyValues.put("hardware", "grouper");
-            final String constant = ResourceUtils.findConstantForKeyValuePairs(keyValues, array);
-            fail("condition without HARDWARE must fail: constant=" + constant);
-        } catch (final RuntimeException e) {
-            assertEquals(e.getMessage(), "Found unknown key: HARDWARE=grouper");
-        }
+        keyValues.clear();
+        keyValues.put("hardware", "grouper");
+        assertNull(ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
+
         keyValues.clear();
         keyValues.put(HARDWARE_KEY, "MAKO");
         assertNull(ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
         keyValues.put(HARDWARE_KEY, "mantaray");
         assertNull(ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
 
-        try {
-            final String constant = ResourceUtils.findConstantForKeyValuePairs(
-                    emptyKeyValue, array);
-            fail("emptyCondition shouldn't match: constant=" + constant);
-        } catch (final RuntimeException e) {
-            assertEquals(e.getMessage(), "Found unknown key: HARDWARE=grouper");
-        }
+        assertNull(ResourceUtils.findConstantForKeyValuePairs(emptyKeyValue, array));
     }
 
     public void testFindConstantForKeyValuePairsCombined() {
@@ -102,6 +108,8 @@
         final String MANUFACTURER_KEY = "MANUFACTURER";
         final String[] array = {
             ",defaultValue",
+            "no_comma",
+            "error_pattern,0.1",
             "HARDWARE=grouper:MANUFACTURER=asus,0.3",
             "HARDWARE=mako:MODEL=Nexus 4,0.4",
             "HARDWARE=manta:MODEL=Nexus 10:MANUFACTURER=samsung,0.2"
@@ -117,25 +125,25 @@
         keyValues.put(HARDWARE_KEY, "grouper");
         keyValues.put(MODEL_KEY, "Nexus 7");
         keyValues.put(MANUFACTURER_KEY, "asus");
-        assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.3");
+        assertEquals("0.3", ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
         assertNull(ResourceUtils.findConstantForKeyValuePairs(keyValues, failArray));
 
         keyValues.clear();
         keyValues.put(HARDWARE_KEY, "mako");
         keyValues.put(MODEL_KEY, "Nexus 4");
         keyValues.put(MANUFACTURER_KEY, "LGE");
-        assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.4");
+        assertEquals("0.4", ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
         assertNull(ResourceUtils.findConstantForKeyValuePairs(keyValues, failArray));
 
         keyValues.clear();
         keyValues.put(HARDWARE_KEY, "manta");
         keyValues.put(MODEL_KEY, "Nexus 10");
         keyValues.put(MANUFACTURER_KEY, "samsung");
-        assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.2");
+        assertEquals("0.2", ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
         assertNull(ResourceUtils.findConstantForKeyValuePairs(keyValues, failArray));
         keyValues.put(HARDWARE_KEY, "mantaray");
         assertNull(ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
-        assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, failArray), "0.2");
+        assertEquals("0.2", ResourceUtils.findConstantForKeyValuePairs(keyValues, failArray));
     }
 
     public void testFindConstantForKeyValuePairsRegexp() {
@@ -144,6 +152,8 @@
         final String MANUFACTURER_KEY = "MANUFACTURER";
         final String[] array = {
             ",defaultValue",
+            "no_comma",
+            "HARDWARE=error_regexp:MANUFACTURER=error[regexp,0.1",
             "HARDWARE=grouper|tilapia:MANUFACTURER=asus,0.3",
             "HARDWARE=[mM][aA][kK][oO]:MODEL=Nexus 4,0.4",
             "HARDWARE=manta.*:MODEL=Nexus 10:MANUFACTURER=samsung,0.2"
@@ -153,24 +163,24 @@
         keyValues.put(HARDWARE_KEY, "grouper");
         keyValues.put(MODEL_KEY, "Nexus 7");
         keyValues.put(MANUFACTURER_KEY, "asus");
-        assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.3");
+        assertEquals("0.3", ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
         keyValues.put(HARDWARE_KEY, "tilapia");
-        assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.3");
+        assertEquals("0.3", ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
 
         keyValues.clear();
         keyValues.put(HARDWARE_KEY, "mako");
         keyValues.put(MODEL_KEY, "Nexus 4");
         keyValues.put(MANUFACTURER_KEY, "LGE");
-        assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.4");
+        assertEquals("0.4", ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
         keyValues.put(HARDWARE_KEY, "MAKO");
-        assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.4");
+        assertEquals("0.4", ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
 
         keyValues.clear();
         keyValues.put(HARDWARE_KEY, "manta");
         keyValues.put(MODEL_KEY, "Nexus 10");
         keyValues.put(MANUFACTURER_KEY, "samsung");
-        assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.2");
+        assertEquals("0.2", ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
         keyValues.put(HARDWARE_KEY, "mantaray");
-        assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.2");
+        assertEquals("0.2", ResourceUtils.findConstantForKeyValuePairs(keyValues, array));
     }
 }
diff --git a/tests/src/com/android/inputmethod/latin/StringUtilsTests.java b/tests/src/com/android/inputmethod/latin/StringUtilsTests.java
index 29e790a..4f26098 100644
--- a/tests/src/com/android/inputmethod/latin/StringUtilsTests.java
+++ b/tests/src/com/android/inputmethod/latin/StringUtilsTests.java
@@ -40,57 +40,62 @@
         }));
     }
 
-    public void testContainsInCsv() {
-        assertFalse("null", StringUtils.containsInCsv("key", null));
-        assertFalse("empty", StringUtils.containsInCsv("key", ""));
-        assertFalse("not in 1 element", StringUtils.containsInCsv("key", "key1"));
-        assertFalse("not in 2 elements", StringUtils.containsInCsv("key", "key1,key2"));
+    public void testContainsInExtraValues() {
+        assertFalse("null", StringUtils.containsInCommaSplittableText("key", null));
+        assertFalse("empty", StringUtils.containsInCommaSplittableText("key", ""));
+        assertFalse("not in 1 element",
+                StringUtils.containsInCommaSplittableText("key", "key1"));
+        assertFalse("not in 2 elements",
+                StringUtils.containsInCommaSplittableText("key", "key1,key2"));
 
-        assertTrue("in 1 element", StringUtils.containsInCsv("key", "key"));
-        assertTrue("in 2 elements", StringUtils.containsInCsv("key", "key1,key"));
+        assertTrue("in 1 element", StringUtils.containsInCommaSplittableText("key", "key"));
+        assertTrue("in 2 elements", StringUtils.containsInCommaSplittableText("key", "key1,key"));
     }
 
-    public void testAppendToCsvIfNotExists() {
-        assertEquals("null", "key", StringUtils.appendToCsvIfNotExists("key", null));
-        assertEquals("empty", "key", StringUtils.appendToCsvIfNotExists("key", ""));
+    public void testAppendToExtraValuesIfNotExists() {
+        assertEquals("null", "key",
+                StringUtils.appendToCommaSplittableTextIfNotExists("key", null));
+        assertEquals("empty", "key",
+                StringUtils.appendToCommaSplittableTextIfNotExists("key", ""));
 
         assertEquals("not in 1 element", "key1,key",
-                StringUtils.appendToCsvIfNotExists("key", "key1"));
+                StringUtils.appendToCommaSplittableTextIfNotExists("key", "key1"));
         assertEquals("not in 2 elements", "key1,key2,key",
-                StringUtils.appendToCsvIfNotExists("key", "key1,key2"));
+                StringUtils.appendToCommaSplittableTextIfNotExists("key", "key1,key2"));
 
         assertEquals("in 1 element", "key",
-                StringUtils.appendToCsvIfNotExists("key", "key"));
+                StringUtils.appendToCommaSplittableTextIfNotExists("key", "key"));
         assertEquals("in 2 elements at position 1", "key,key2",
-                StringUtils.appendToCsvIfNotExists("key", "key,key2"));
+                StringUtils.appendToCommaSplittableTextIfNotExists("key", "key,key2"));
         assertEquals("in 2 elements at position 2", "key1,key",
-                StringUtils.appendToCsvIfNotExists("key", "key1,key"));
+                StringUtils.appendToCommaSplittableTextIfNotExists("key", "key1,key"));
         assertEquals("in 3 elements at position 2", "key1,key,key3",
-                StringUtils.appendToCsvIfNotExists("key", "key1,key,key3"));
+                StringUtils.appendToCommaSplittableTextIfNotExists("key", "key1,key,key3"));
     }
 
-    public void testRemoveFromCsvIfExists() {
-        assertEquals("null", "", StringUtils.removeFromCsvIfExists("key", null));
-        assertEquals("empty", "", StringUtils.removeFromCsvIfExists("key", ""));
+    public void testRemoveFromExtraValuesIfExists() {
+        assertEquals("null", "", StringUtils.removeFromCommaSplittableTextIfExists("key", null));
+        assertEquals("empty", "", StringUtils.removeFromCommaSplittableTextIfExists("key", ""));
 
         assertEquals("not in 1 element", "key1",
-                StringUtils.removeFromCsvIfExists("key", "key1"));
+                StringUtils.removeFromCommaSplittableTextIfExists("key", "key1"));
         assertEquals("not in 2 elements", "key1,key2",
-                StringUtils.removeFromCsvIfExists("key", "key1,key2"));
+                StringUtils.removeFromCommaSplittableTextIfExists("key", "key1,key2"));
 
         assertEquals("in 1 element", "",
-                StringUtils.removeFromCsvIfExists("key", "key"));
+                StringUtils.removeFromCommaSplittableTextIfExists("key", "key"));
         assertEquals("in 2 elements at position 1", "key2",
-                StringUtils.removeFromCsvIfExists("key", "key,key2"));
+                StringUtils.removeFromCommaSplittableTextIfExists("key", "key,key2"));
         assertEquals("in 2 elements at position 2", "key1",
-                StringUtils.removeFromCsvIfExists("key", "key1,key"));
+                StringUtils.removeFromCommaSplittableTextIfExists("key", "key1,key"));
         assertEquals("in 3 elements at position 2", "key1,key3",
-                StringUtils.removeFromCsvIfExists("key", "key1,key,key3"));
+                StringUtils.removeFromCommaSplittableTextIfExists("key", "key1,key,key3"));
 
         assertEquals("in 3 elements at position 1,2,3", "",
-                StringUtils.removeFromCsvIfExists("key", "key,key,key"));
+                StringUtils.removeFromCommaSplittableTextIfExists("key", "key,key,key"));
         assertEquals("in 5 elements at position 2,4", "key1,key3,key5",
-                StringUtils.removeFromCsvIfExists("key", "key1,key,key3,key,key5"));
+                StringUtils.removeFromCommaSplittableTextIfExists(
+                        "key", "key1,key,key3,key,key5"));
     }