diff --git a/java/src/com/android/inputmethod/keyboard/KeyboardSwitcher.java b/java/src/com/android/inputmethod/keyboard/KeyboardSwitcher.java
index 37a4bf8..fd0be6f 100644
--- a/java/src/com/android/inputmethod/keyboard/KeyboardSwitcher.java
+++ b/java/src/com/android/inputmethod/keyboard/KeyboardSwitcher.java
@@ -204,10 +204,12 @@
         keyboardView.updateShortcutKey(mSubtypeSwitcher.isShortcutImeReady());
         final boolean subtypeChanged = (oldKeyboard == null)
                 || !keyboard.mId.mLocale.equals(oldKeyboard.mId.mLocale);
-        final boolean needsToDisplayLanguage = mSubtypeSwitcher.needsToDisplayLanguage(
+        final int languageOnSpacebarFormatType = mSubtypeSwitcher.getLanguageOnSpacebarFormatType(
                 keyboard.mId.mSubtype);
-        keyboardView.startDisplayLanguageOnSpacebar(subtypeChanged, needsToDisplayLanguage,
-                RichInputMethodManager.getInstance().hasMultipleEnabledIMEsOrSubtypes(true));
+        final boolean hasMultipleEnabledIMEsOrSubtypes = RichInputMethodManager.getInstance()
+                .hasMultipleEnabledIMEsOrSubtypes(true /* shouldIncludeAuxiliarySubtypes */);
+        keyboardView.startDisplayLanguageOnSpacebar(subtypeChanged, languageOnSpacebarFormatType,
+                hasMultipleEnabledIMEsOrSubtypes);
     }
 
     public Keyboard getKeyboard() {
diff --git a/java/src/com/android/inputmethod/keyboard/MainKeyboardView.java b/java/src/com/android/inputmethod/keyboard/MainKeyboardView.java
index 03425ef..0f9c39a 100644
--- a/java/src/com/android/inputmethod/keyboard/MainKeyboardView.java
+++ b/java/src/com/android/inputmethod/keyboard/MainKeyboardView.java
@@ -49,6 +49,7 @@
 import com.android.inputmethod.keyboard.internal.KeyDrawParams;
 import com.android.inputmethod.keyboard.internal.KeyPreviewChoreographer;
 import com.android.inputmethod.keyboard.internal.KeyPreviewDrawParams;
+import com.android.inputmethod.keyboard.internal.LanguageOnSpacebarHelper;
 import com.android.inputmethod.keyboard.internal.NonDistinctMultitouchHelper;
 import com.android.inputmethod.keyboard.internal.SlidingKeyInputDrawingPreview;
 import com.android.inputmethod.keyboard.internal.TimerHandler;
@@ -123,7 +124,7 @@
     // Stuff to draw language name on spacebar.
     private final int mLanguageOnSpacebarFinalAlpha;
     private ObjectAnimator mLanguageOnSpacebarFadeoutAnimator;
-    private boolean mNeedsToDisplayLanguage;
+    private int mLanguageOnSpacebarFormatType;
     private boolean mHasMultipleEnabledIMEsOrSubtypes;
     private int mLanguageOnSpacebarAnimAlpha = Constants.Color.ALPHA_OPAQUE;
     private final float mLanguageOnSpacebarTextRatio;
@@ -811,14 +812,16 @@
     }
 
     public void startDisplayLanguageOnSpacebar(final boolean subtypeChanged,
-            final boolean needsToDisplayLanguage, final boolean hasMultipleEnabledIMEsOrSubtypes) {
-        mNeedsToDisplayLanguage = needsToDisplayLanguage;
+            final int languageOnSpacebarFormatType,
+            final boolean hasMultipleEnabledIMEsOrSubtypes) {
+        mLanguageOnSpacebarFormatType = languageOnSpacebarFormatType;
         mHasMultipleEnabledIMEsOrSubtypes = hasMultipleEnabledIMEsOrSubtypes;
         final ObjectAnimator animator = mLanguageOnSpacebarFadeoutAnimator;
         if (animator == null) {
-            mNeedsToDisplayLanguage = false;
+            mLanguageOnSpacebarFormatType = LanguageOnSpacebarHelper.FORMAT_TYPE_NONE;
         } else {
-            if (subtypeChanged && needsToDisplayLanguage) {
+            if (subtypeChanged
+                    && languageOnSpacebarFormatType != LanguageOnSpacebarHelper.FORMAT_TYPE_NONE) {
                 setLanguageOnSpacebarAnimAlpha(Constants.Color.ALPHA_OPAQUE);
                 if (animator.isStarted()) {
                     animator.cancel();
@@ -919,9 +922,11 @@
     private String layoutLanguageOnSpacebar(final Paint paint,
             final InputMethodSubtype subtype, final int width) {
         // Choose appropriate language name to fit into the width.
-        final String fullText = SpacebarLanguageUtils.getFullDisplayName(subtype);
-        if (fitsTextIntoWidth(width, fullText, paint)) {
-            return fullText;
+        if (mLanguageOnSpacebarFormatType == LanguageOnSpacebarHelper.FORMAT_TYPE_FULL_LOCALE) {
+            final String fullText = SpacebarLanguageUtils.getFullDisplayName(subtype);
+            if (fitsTextIntoWidth(width, fullText, paint)) {
+                return fullText;
+            }
         }
 
         final String middleText = SpacebarLanguageUtils.getMiddleDisplayName(subtype);
@@ -937,7 +942,7 @@
         final int height = key.getHeight();
 
         // If input language are explicitly selected.
-        if (mNeedsToDisplayLanguage) {
+        if (mLanguageOnSpacebarFormatType != LanguageOnSpacebarHelper.FORMAT_TYPE_NONE) {
             paint.setTextAlign(Align.CENTER);
             paint.setTypeface(Typeface.DEFAULT);
             paint.setTextSize(mLanguageOnSpacebarTextSize);
diff --git a/java/src/com/android/inputmethod/keyboard/internal/LanguageOnSpacebarHelper.java b/java/src/com/android/inputmethod/keyboard/internal/LanguageOnSpacebarHelper.java
new file mode 100644
index 0000000..6400a24
--- /dev/null
+++ b/java/src/com/android/inputmethod/keyboard/internal/LanguageOnSpacebarHelper.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2014 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 android.view.inputmethod.InputMethodSubtype;
+
+import com.android.inputmethod.latin.utils.SubtypeLocaleUtils;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * This class determines that the language name on the spacebar should be displayed in what format.
+ */
+public final class LanguageOnSpacebarHelper {
+    public static final int FORMAT_TYPE_NONE = 0;
+    public static final int FORMAT_TYPE_LANGUAGE_ONLY = 1;
+    public static final int FORMAT_TYPE_FULL_LOCALE = 2;
+
+    private List<InputMethodSubtype> mEnabledSubtypes = Collections.emptyList();
+    private boolean mIsSystemLanguageSameAsInputLanguage;
+
+    public int getLanguageOnSpacebarFormatType(final InputMethodSubtype subtype) {
+        if (SubtypeLocaleUtils.isNoLanguage(subtype)) {
+            return FORMAT_TYPE_FULL_LOCALE;
+        }
+        // Only this subtype is enabled and equals to the system locale.
+        if (mEnabledSubtypes.size() < 2 && mIsSystemLanguageSameAsInputLanguage) {
+            return FORMAT_TYPE_NONE;
+        }
+        final String keyboardLanguage = SubtypeLocaleUtils.getSubtypeLocale(subtype).getLanguage();
+        final String keyboardLayout = SubtypeLocaleUtils.getKeyboardLayoutSetName(subtype);
+        int sameLanguageAndLayoutCount = 0;
+        for (final InputMethodSubtype ims : mEnabledSubtypes) {
+            final String language = SubtypeLocaleUtils.getSubtypeLocale(ims).getLanguage();
+            if (keyboardLanguage.equals(language) && keyboardLayout.equals(
+                    SubtypeLocaleUtils.getKeyboardLayoutSetName(ims))) {
+                sameLanguageAndLayoutCount++;
+            }
+        }
+        // Display full locale name only when there are multiple subtypes that have the same
+        // locale and keyboard layout. Otherwise displaying language name is enough.
+        return sameLanguageAndLayoutCount > 1 ? FORMAT_TYPE_FULL_LOCALE
+                : FORMAT_TYPE_LANGUAGE_ONLY;
+    }
+
+    public void updateEnabledSubtypes(final List<InputMethodSubtype> enabledSubtypes) {
+        mEnabledSubtypes = enabledSubtypes;
+    }
+
+    public void updateIsSystemLanguageSameAsInputLanguage(final boolean isSame) {
+        mIsSystemLanguageSameAsInputLanguage = isSame;
+    }
+}
diff --git a/java/src/com/android/inputmethod/keyboard/internal/NeedsToDisplayLanguage.java b/java/src/com/android/inputmethod/keyboard/internal/NeedsToDisplayLanguage.java
deleted file mode 100644
index e548de5..0000000
--- a/java/src/com/android/inputmethod/keyboard/internal/NeedsToDisplayLanguage.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * Copyright (C) 2014 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 android.view.inputmethod.InputMethodSubtype;
-
-import com.android.inputmethod.latin.utils.SubtypeLocaleUtils;
-
-/**
- * This class determines that the language name on the spacebar should be displayed or not.
- */
-public final class NeedsToDisplayLanguage {
-    private int mEnabledSubtypeCount;
-    private boolean mIsSystemLanguageSameAsInputLanguage;
-
-    public boolean needsToDisplayLanguage(final InputMethodSubtype subtype) {
-        if (SubtypeLocaleUtils.isNoLanguage(subtype)) {
-            return true;
-        }
-        return mEnabledSubtypeCount >= 2 || !mIsSystemLanguageSameAsInputLanguage;
-    }
-
-    public void updateEnabledSubtypeCount(final int count) {
-        mEnabledSubtypeCount = count;
-    }
-
-    public void updateIsSystemLanguageSameAsInputLanguage(final boolean isSame) {
-        mIsSystemLanguageSameAsInputLanguage = isSame;
-    }
-}
diff --git a/java/src/com/android/inputmethod/latin/SubtypeSwitcher.java b/java/src/com/android/inputmethod/latin/SubtypeSwitcher.java
index d430122..0211339 100644
--- a/java/src/com/android/inputmethod/latin/SubtypeSwitcher.java
+++ b/java/src/com/android/inputmethod/latin/SubtypeSwitcher.java
@@ -34,7 +34,7 @@
 import com.android.inputmethod.annotations.UsedForTesting;
 import com.android.inputmethod.compat.InputMethodSubtypeCompatUtils;
 import com.android.inputmethod.keyboard.KeyboardSwitcher;
-import com.android.inputmethod.keyboard.internal.NeedsToDisplayLanguage;
+import com.android.inputmethod.keyboard.internal.LanguageOnSpacebarHelper;
 import com.android.inputmethod.latin.utils.LocaleUtils;
 import com.android.inputmethod.latin.utils.SubtypeLocaleUtils;
 
@@ -54,7 +54,8 @@
     private /* final */ Resources mResources;
     private /* final */ ConnectivityManager mConnectivityManager;
 
-    private final NeedsToDisplayLanguage mNeedsToDisplayLanguage = new NeedsToDisplayLanguage();
+    private final LanguageOnSpacebarHelper mLanguageOnSpacebarHelper =
+            new LanguageOnSpacebarHelper();
     private InputMethodInfo mShortcutInputMethodInfo;
     private InputMethodSubtype mShortcutSubtype;
     private InputMethodSubtype mNoLanguageSubtype;
@@ -127,7 +128,7 @@
     public void updateParametersOnStartInputView() {
         final List<InputMethodSubtype> enabledSubtypesOfThisIme =
                 mRichImm.getMyEnabledInputMethodSubtypeList(true);
-        mNeedsToDisplayLanguage.updateEnabledSubtypeCount(enabledSubtypesOfThisIme.size());
+        mLanguageOnSpacebarHelper.updateEnabledSubtypes(enabledSubtypesOfThisIme);
         updateShortcutIME();
     }
 
@@ -176,7 +177,7 @@
         final boolean sameLanguage = systemLocale.getLanguage().equals(newLocale.getLanguage());
         final boolean implicitlyEnabled =
                 mRichImm.checkIfSubtypeBelongsToThisImeAndImplicitlyEnabled(newSubtype);
-        mNeedsToDisplayLanguage.updateIsSystemLanguageSameAsInputLanguage(
+        mLanguageOnSpacebarHelper.updateIsSystemLanguageSameAsInputLanguage(
                 sameLocale || (sameLanguage && implicitlyEnabled));
 
         updateShortcutIME();
@@ -249,8 +250,8 @@
     // Subtype Switching functions //
     //////////////////////////////////
 
-    public boolean needsToDisplayLanguage(final InputMethodSubtype subtype) {
-        return mNeedsToDisplayLanguage.needsToDisplayLanguage(subtype);
+    public int getLanguageOnSpacebarFormatType(final InputMethodSubtype subtype) {
+        return mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(subtype);
     }
 
     public boolean isSystemLocaleSameAsLocaleOfAllEnabledSubtypesOfEnabledImes() {
diff --git a/native/jni/Android.mk b/native/jni/Android.mk
index c1372bd..5c117ce 100644
--- a/native/jni/Android.mk
+++ b/native/jni/Android.mk
@@ -87,6 +87,8 @@
 LOCAL_LDFLAGS += -ldl
 
 include $(BUILD_SHARED_LIBRARY)
-
 #################### Clean up the tmp vars
 include $(LOCAL_PATH)/CleanupNativeFileList.mk
+
+#################### Unit test on host environment
+include $(LOCAL_PATH)/HostUnitTests.mk
diff --git a/native/jni/CleanupNativeFileList.mk b/native/jni/CleanupNativeFileList.mk
index 5420f16..1738f8c 100644
--- a/native/jni/CleanupNativeFileList.mk
+++ b/native/jni/CleanupNativeFileList.mk
@@ -13,5 +13,6 @@
 # limitations under the License.
 
 LATIN_IME_CORE_SRC_FILES :=
+LATIN_IME_CORE_TEST_FILES :=
 LATIN_IME_JNI_SRC_FILES :=
 LATIN_IME_SRC_DIR :=
diff --git a/native/jni/HostUnitTests.mk b/native/jni/HostUnitTests.mk
new file mode 100644
index 0000000..828edce
--- /dev/null
+++ b/native/jni/HostUnitTests.mk
@@ -0,0 +1,53 @@
+# Copyright (C) 2014 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.
+
+LOCAL_PATH := $(call my-dir)
+
+######################################
+include $(CLEAR_VARS)
+
+include $(LOCAL_PATH)/NativeFileList.mk
+
+#################### Host library for unit test
+# TODO: Remove -std=c++11 once it is set by default on host build.
+LATIN_IME_SRC_DIR := src
+LOCAL_CFLAGS += -std=c++11 -Wno-unused-parameter -Wno-unused-function
+LOCAL_CLANG := true
+LOCAL_C_INCLUDES += $(LOCAL_PATH)/$(LATIN_IME_SRC_DIR)
+LOCAL_IS_HOST_MODULE := true
+LOCAL_MODULE := liblatinime_host_static_for_unittests
+LOCAL_MODULE_TAGS := optional
+LOCAL_NDK_STL_VARIANT := c++_static
+LOCAL_SRC_FILES := $(addprefix $(LATIN_IME_SRC_DIR)/, $(LATIN_IME_CORE_SRC_FILES))
+include $(BUILD_HOST_STATIC_LIBRARY)
+
+#################### Host native tests
+include $(CLEAR_VARS)
+LATIN_IME_TEST_SRC_DIR := tests
+# TODO: Remove -std=c++11 once it is set by default on host build.
+LOCAL_CFLAGS += -std=c++11 -Wno-unused-parameter -Wno-unused-function
+LOCAL_CLANG := true
+LOCAL_C_INCLUDES += $(LOCAL_PATH)/$(LATIN_IME_SRC_DIR)
+LOCAL_IS_HOST_MODULE := true
+LOCAL_MODULE := liblatinime_host_unittests
+LOCAL_MODULE_TAGS := tests
+LOCAL_NDK_STL_VARIANT := c++_static
+LOCAL_SRC_FILES := $(addprefix $(LATIN_IME_TEST_SRC_DIR)/, $(LATIN_IME_CORE_TEST_FILES))
+LOCAL_STATIC_LIBRARIES += liblatinime_host_static_for_unittests libgtest_host libgtest_main_host
+include $(BUILD_HOST_NATIVE_TEST)
+
+#################### Clean up the tmp vars
+LATIN_IME_SRC_DIR :=
+LATIN_IME_TEST_SRC_DIR :=
+include $(LOCAL_PATH)/CleanupNativeFileList.mk
diff --git a/native/jni/NativeFileList.mk b/native/jni/NativeFileList.mk
index 2ee4caa..3da9d56 100644
--- a/native/jni/NativeFileList.mk
+++ b/native/jni/NativeFileList.mk
@@ -99,3 +99,6 @@
         char_utils.cpp \
         log_utils.cpp \
         time_keeper.cpp)
+
+LATIN_IME_CORE_TEST_FILES := \
+    utils/autocorrection_threshold_utils_test.cpp
diff --git a/native/jni/run-tests.sh b/native/jni/run-tests.sh
new file mode 100755
index 0000000..898ea16
--- /dev/null
+++ b/native/jni/run-tests.sh
@@ -0,0 +1,29 @@
+#!/bin/bash
+# Copyright 2014, 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.
+
+if [[ $(type -t mmm) != function ]]; then
+echo "Usage:" 1>&2
+echo "    source $0" 1>&2
+echo "  or" 1>&2
+echo "    . $0" 1>&2
+exit 1
+fi
+
+pushd $PWD > /dev/null
+cd $(gettop)
+mmm -j16 packages/inputmethods/LatinIME/native/jni || \
+    make -j16 liblatinime_host_unittests
+${ANDROID_HOST_OUT}/bin/liblatinime_host_unittests
+popd > /dev/null
\ No newline at end of file
diff --git a/native/jni/src/suggest/policyimpl/typing/scoring_params.cpp b/native/jni/src/suggest/policyimpl/typing/scoring_params.cpp
index c4c5716..fa9600c 100644
--- a/native/jni/src/suggest/policyimpl/typing/scoring_params.cpp
+++ b/native/jni/src/suggest/policyimpl/typing/scoring_params.cpp
@@ -52,8 +52,8 @@
 const float ScoringParams::COST_NEW_WORD = 0.0314f;
 const float ScoringParams::COST_SECOND_OR_LATER_WORD_FIRST_CHAR_UPPERCASE = 0.3224f;
 const float ScoringParams::DISTANCE_WEIGHT_LANGUAGE = 1.1214f;
-const float ScoringParams::COST_FIRST_LOOKAHEAD = 0.4836f;
-const float ScoringParams::COST_LOOKAHEAD = 0.00624f;
+const float ScoringParams::COST_FIRST_COMPLETION = 0.4836f;
+const float ScoringParams::COST_COMPLETION = 0.00624f;
 const float ScoringParams::HAS_PROXIMITY_TERMINAL_COST = 0.0683f;
 const float ScoringParams::HAS_EDIT_CORRECTION_TERMINAL_COST = 0.0362f;
 const float ScoringParams::HAS_MULTI_WORD_TERMINAL_COST = 0.4182f;
diff --git a/native/jni/src/suggest/policyimpl/typing/scoring_params.h b/native/jni/src/suggest/policyimpl/typing/scoring_params.h
index de7410d..b669620 100644
--- a/native/jni/src/suggest/policyimpl/typing/scoring_params.h
+++ b/native/jni/src/suggest/policyimpl/typing/scoring_params.h
@@ -59,8 +59,8 @@
     static const float COST_NEW_WORD;
     static const float COST_SECOND_OR_LATER_WORD_FIRST_CHAR_UPPERCASE;
     static const float DISTANCE_WEIGHT_LANGUAGE;
-    static const float COST_FIRST_LOOKAHEAD;
-    static const float COST_LOOKAHEAD;
+    static const float COST_FIRST_COMPLETION;
+    static const float COST_COMPLETION;
     static const float HAS_PROXIMITY_TERMINAL_COST;
     static const float HAS_EDIT_CORRECTION_TERMINAL_COST;
     static const float HAS_MULTI_WORD_TERMINAL_COST;
diff --git a/native/jni/src/suggest/policyimpl/typing/typing_weighting.h b/native/jni/src/suggest/policyimpl/typing/typing_weighting.h
index b36605a..0ba439b 100644
--- a/native/jni/src/suggest/policyimpl/typing/typing_weighting.h
+++ b/native/jni/src/suggest/policyimpl/typing/typing_weighting.h
@@ -166,8 +166,8 @@
         const bool firstCompletion = dicNode->getInputIndex(0)
                 == traverseSession->getInputSize();
         // TODO: Change the cost for the first completion for the gesture?
-        const float cost = firstCompletion ? ScoringParams::COST_FIRST_LOOKAHEAD
-                : ScoringParams::COST_LOOKAHEAD;
+        const float cost = firstCompletion ? ScoringParams::COST_FIRST_COMPLETION
+                : ScoringParams::COST_COMPLETION;
         return cost;
     }
 
diff --git a/native/jni/tests/utils/autocorrection_threshold_utils_test.cpp b/native/jni/tests/utils/autocorrection_threshold_utils_test.cpp
new file mode 100644
index 0000000..cc8db70
--- /dev/null
+++ b/native/jni/tests/utils/autocorrection_threshold_utils_test.cpp
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2014 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.
+ */
+
+#include "utils/autocorrection_threshold_utils.h"
+
+#include <gtest/gtest.h>
+
+#include <vector>
+
+namespace latinime {
+namespace {
+
+int CalcEditDistance(const std::vector<int> &before,
+        const std::vector<int> &after) {
+    return AutocorrectionThresholdUtils::editDistance(
+            &before[0], before.size(), &after[0], after.size());
+}
+
+TEST(AutocorrectionThresholdUtilsTest, SameData) {
+    EXPECT_EQ(0, CalcEditDistance({1}, {1}));
+    EXPECT_EQ(0, CalcEditDistance({2, 2}, {2, 2}));
+    EXPECT_EQ(0, CalcEditDistance({3, 3, 3}, {3, 3, 3}));
+}
+
+}  // namespace
+}  // namespace latinime
diff --git a/tests/src/com/android/inputmethod/keyboard/internal/LanguageOnSpacebarHelperTests.java b/tests/src/com/android/inputmethod/keyboard/internal/LanguageOnSpacebarHelperTests.java
new file mode 100644
index 0000000..0be1e37
--- /dev/null
+++ b/tests/src/com/android/inputmethod/keyboard/internal/LanguageOnSpacebarHelperTests.java
@@ -0,0 +1,167 @@
+/*
+ * Copyright (C) 2014 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 static com.android.inputmethod.keyboard.internal.LanguageOnSpacebarHelper.FORMAT_TYPE_FULL_LOCALE;
+import static com.android.inputmethod.keyboard.internal.LanguageOnSpacebarHelper.FORMAT_TYPE_LANGUAGE_ONLY;
+import static com.android.inputmethod.keyboard.internal.LanguageOnSpacebarHelper.FORMAT_TYPE_NONE;
+
+import android.content.Context;
+import android.test.AndroidTestCase;
+import android.test.suitebuilder.annotation.SmallTest;
+import android.view.inputmethod.InputMethodSubtype;
+
+import com.android.inputmethod.latin.RichInputMethodManager;
+import com.android.inputmethod.latin.utils.AdditionalSubtypeUtils;
+import com.android.inputmethod.latin.utils.SubtypeLocaleUtils;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Locale;
+
+@SmallTest
+public class LanguageOnSpacebarHelperTests extends AndroidTestCase {
+    private final LanguageOnSpacebarHelper mLanguageOnSpacebarHelper =
+            new LanguageOnSpacebarHelper();
+
+    private RichInputMethodManager mRichImm;
+
+    InputMethodSubtype EN_US_QWERTY;
+    InputMethodSubtype EN_GB_QWERTY;
+    InputMethodSubtype FR_AZERTY;
+    InputMethodSubtype FR_CA_QWERTY;
+    InputMethodSubtype FR_CH_SWISS;
+    InputMethodSubtype FR_CH_QWERTY;
+    InputMethodSubtype FR_CH_QWERTZ;
+    InputMethodSubtype ZZ_QWERTY;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        final Context context = getContext();
+        RichInputMethodManager.init(context);
+        mRichImm = RichInputMethodManager.getInstance();
+        SubtypeLocaleUtils.init(context);
+
+        EN_US_QWERTY = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet(
+                Locale.US.toString(), "qwerty");
+        EN_GB_QWERTY = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet(
+                Locale.UK.toString(), "qwerty");
+        FR_AZERTY = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet(
+                Locale.FRENCH.toString(), "azerty");
+        FR_CA_QWERTY = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet(
+                Locale.CANADA_FRENCH.toString(), "qwerty");
+        FR_CH_SWISS = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet(
+                "fr_CH", "swiss");
+        FR_CH_QWERTZ = AdditionalSubtypeUtils.createAdditionalSubtype(
+                "fr_CH", "qwertz", null);
+        FR_CH_QWERTY = AdditionalSubtypeUtils.createAdditionalSubtype(
+                "fr_CH", "qwerty", null);
+        ZZ_QWERTY = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet(
+                SubtypeLocaleUtils.NO_LANGUAGE, "qwerty");
+    }
+
+    private static List<InputMethodSubtype> asList(final InputMethodSubtype ... subtypes) {
+        return Arrays.asList(subtypes);
+    }
+
+    public void testOneSubtype() {
+        mLanguageOnSpacebarHelper.updateEnabledSubtypes(asList(EN_US_QWERTY));
+        mLanguageOnSpacebarHelper.updateIsSystemLanguageSameAsInputLanguage(true /* isSame */);
+        assertEquals("one same English (US)", FORMAT_TYPE_NONE,
+                mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(EN_US_QWERTY));
+        assertEquals("one same NoLanguage", FORMAT_TYPE_FULL_LOCALE,
+                mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(ZZ_QWERTY));
+
+        mLanguageOnSpacebarHelper.updateEnabledSubtypes(asList(FR_AZERTY));
+        mLanguageOnSpacebarHelper.updateIsSystemLanguageSameAsInputLanguage(false /* isSame */);
+        assertEquals("one diff English (US)", FORMAT_TYPE_LANGUAGE_ONLY,
+                mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(EN_US_QWERTY));
+        assertEquals("one diff NoLanguage", FORMAT_TYPE_FULL_LOCALE,
+                mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(ZZ_QWERTY));
+    }
+
+    public void testTwoSubtypes() {
+        mLanguageOnSpacebarHelper.updateEnabledSubtypes(asList(EN_US_QWERTY, FR_AZERTY));
+
+        mLanguageOnSpacebarHelper.updateIsSystemLanguageSameAsInputLanguage(true /* isSame */);
+        assertEquals("two same English (US)", FORMAT_TYPE_LANGUAGE_ONLY,
+                mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(EN_US_QWERTY));
+        assertEquals("two same French)", FORMAT_TYPE_LANGUAGE_ONLY,
+                mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(FR_AZERTY));
+        assertEquals("two same NoLanguage", FORMAT_TYPE_FULL_LOCALE,
+                mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(ZZ_QWERTY));
+
+        mLanguageOnSpacebarHelper.updateIsSystemLanguageSameAsInputLanguage(false /* isSame */);
+        assertEquals("two diff English (US)", FORMAT_TYPE_LANGUAGE_ONLY,
+                mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(EN_US_QWERTY));
+        assertEquals("two diff French", FORMAT_TYPE_LANGUAGE_ONLY,
+                mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(FR_AZERTY));
+        assertEquals("two diff NoLanguage", FORMAT_TYPE_FULL_LOCALE,
+                mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(ZZ_QWERTY));
+    }
+
+    public void testSameLanuageSubtypes() {
+        mLanguageOnSpacebarHelper.updateEnabledSubtypes(
+                asList(EN_US_QWERTY, EN_GB_QWERTY, FR_AZERTY, ZZ_QWERTY));
+
+        mLanguageOnSpacebarHelper.updateIsSystemLanguageSameAsInputLanguage(true /* isSame */);
+        assertEquals("two same English (US)", FORMAT_TYPE_FULL_LOCALE,
+                mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(EN_US_QWERTY));
+        assertEquals("two same English (UK)", FORMAT_TYPE_FULL_LOCALE,
+                mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(EN_GB_QWERTY));
+        assertEquals("two same NoLanguage", FORMAT_TYPE_FULL_LOCALE,
+                mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(ZZ_QWERTY));
+
+        mLanguageOnSpacebarHelper.updateIsSystemLanguageSameAsInputLanguage(false /* isSame */);
+        assertEquals("two diff English (US)", FORMAT_TYPE_FULL_LOCALE,
+                mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(EN_US_QWERTY));
+        assertEquals("two diff English (UK)", FORMAT_TYPE_FULL_LOCALE,
+                mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(EN_GB_QWERTY));
+        assertEquals("two diff NoLanguage", FORMAT_TYPE_FULL_LOCALE,
+                mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(ZZ_QWERTY));
+    }
+
+    public void testMultiSameLanuageSubtypes() {
+        mLanguageOnSpacebarHelper.updateEnabledSubtypes(
+                asList(FR_AZERTY, FR_CA_QWERTY, FR_CH_SWISS, FR_CH_QWERTY, FR_CH_QWERTZ));
+
+        mLanguageOnSpacebarHelper.updateIsSystemLanguageSameAsInputLanguage(true /* isSame */);
+        assertEquals("multi same French", FORMAT_TYPE_LANGUAGE_ONLY,
+                mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(FR_AZERTY));
+        assertEquals("multi same French (CA)", FORMAT_TYPE_FULL_LOCALE,
+                mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(FR_CA_QWERTY));
+        assertEquals("multi same French (CH)", FORMAT_TYPE_LANGUAGE_ONLY,
+                mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(FR_CH_SWISS));
+        assertEquals("multi same French (CH) (QWERTY)", FORMAT_TYPE_FULL_LOCALE,
+                mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(FR_CH_QWERTY));
+        assertEquals("multi same French (CH) (QWERTZ)", FORMAT_TYPE_LANGUAGE_ONLY,
+                mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(FR_CH_QWERTZ));
+
+        mLanguageOnSpacebarHelper.updateIsSystemLanguageSameAsInputLanguage(false /* isSame */);
+        assertEquals("multi diff French", FORMAT_TYPE_LANGUAGE_ONLY,
+                mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(FR_AZERTY));
+        assertEquals("multi diff French (CA)", FORMAT_TYPE_FULL_LOCALE,
+                mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(FR_CA_QWERTY));
+        assertEquals("multi diff French (CH)", FORMAT_TYPE_LANGUAGE_ONLY,
+                mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(FR_CH_SWISS));
+        assertEquals("multi diff French (CH) (QWERTY)", FORMAT_TYPE_FULL_LOCALE,
+                mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(FR_CH_QWERTY));
+        assertEquals("multi diff French (CH) (QWERTZ)", FORMAT_TYPE_LANGUAGE_ONLY,
+                mLanguageOnSpacebarHelper.getLanguageOnSpacebarFormatType(FR_CH_QWERTZ));
+    }
+}
diff --git a/tests/src/com/android/inputmethod/keyboard/internal/NeedsToDisplayLanguageTests.java b/tests/src/com/android/inputmethod/keyboard/internal/NeedsToDisplayLanguageTests.java
deleted file mode 100644
index e03bce1..0000000
--- a/tests/src/com/android/inputmethod/keyboard/internal/NeedsToDisplayLanguageTests.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * Copyright (C) 2014 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 android.content.Context;
-import android.test.AndroidTestCase;
-import android.test.suitebuilder.annotation.SmallTest;
-import android.view.inputmethod.InputMethodSubtype;
-
-import com.android.inputmethod.latin.RichInputMethodManager;
-import com.android.inputmethod.latin.utils.SubtypeLocaleUtils;
-
-import java.util.Locale;
-
-@SmallTest
-public class NeedsToDisplayLanguageTests extends AndroidTestCase {
-    private final NeedsToDisplayLanguage mNeedsToDisplayLanguage = new NeedsToDisplayLanguage();
-
-    private RichInputMethodManager mRichImm;
-
-    InputMethodSubtype EN_US;
-    InputMethodSubtype FR;
-    InputMethodSubtype ZZ;
-
-    @Override
-    protected void setUp() throws Exception {
-        super.setUp();
-        final Context context = getContext();
-        RichInputMethodManager.init(context);
-        mRichImm = RichInputMethodManager.getInstance();
-        SubtypeLocaleUtils.init(context);
-
-        EN_US = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet(
-                Locale.US.toString(), "qwerty");
-        FR = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet(
-                Locale.FRENCH.toString(), "azerty");
-        ZZ = mRichImm.findSubtypeByLocaleAndKeyboardLayoutSet(
-                SubtypeLocaleUtils.NO_LANGUAGE, "qwerty");
-    }
-
-    public void testOneSubtype() {
-        mNeedsToDisplayLanguage.updateEnabledSubtypeCount(1);
-
-        mNeedsToDisplayLanguage.updateIsSystemLanguageSameAsInputLanguage(true /* isSame */);
-        assertFalse("one same English (US)", mNeedsToDisplayLanguage.needsToDisplayLanguage(EN_US));
-        assertTrue("one same NoLanguage", mNeedsToDisplayLanguage.needsToDisplayLanguage(ZZ));
-
-        mNeedsToDisplayLanguage.updateIsSystemLanguageSameAsInputLanguage(false /* isSame */);
-        assertTrue("one diff English (US)", mNeedsToDisplayLanguage.needsToDisplayLanguage(EN_US));
-        assertTrue("one diff NoLanguage", mNeedsToDisplayLanguage.needsToDisplayLanguage(ZZ));
-    }
-
-    public void testTwoSubtype() {
-        mNeedsToDisplayLanguage.updateEnabledSubtypeCount(2);
-
-        mNeedsToDisplayLanguage.updateIsSystemLanguageSameAsInputLanguage(true /* isSame */);
-        assertTrue("two same English (US)", mNeedsToDisplayLanguage.needsToDisplayLanguage(EN_US));
-        assertTrue("two same French", mNeedsToDisplayLanguage.needsToDisplayLanguage(FR));
-        assertTrue("two same NoLanguage", mNeedsToDisplayLanguage.needsToDisplayLanguage(ZZ));
-
-        mNeedsToDisplayLanguage.updateIsSystemLanguageSameAsInputLanguage(false /* isSame */);
-        assertTrue("two diff English (US)", mNeedsToDisplayLanguage.needsToDisplayLanguage(EN_US));
-        assertTrue("two diff French", mNeedsToDisplayLanguage.needsToDisplayLanguage(ZZ));
-        assertTrue("two diff NoLanguage", mNeedsToDisplayLanguage.needsToDisplayLanguage(FR));
-    }
-}