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

Commit cf03ff02 authored by Jean Chalard's avatar Jean Chalard
Browse files

Fix a test. 

This fixes two separate problems:
- The word finds itself with two separate suggestion spans.
This is fine for LatinIME, but it's hard to predict whether it's
fine for other interested parties (other keyboards).
- The test for the blue underline was incorrect.

Change-Id: I3ecc849676851bf25a25238d694adaa956521a26
parent 5a885e85

java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java

+29 −17
Original line number Diff line number Diff line
@@ -1355,6 +1355,7 @@ public final class InputLogic { 
        final String previousWord = mLastComposedWord.mPrevWord;

        final CharSequence originallyTypedWord = mLastComposedWord.mTypedWord;

        final CharSequence committedWord = mLastComposedWord.mCommittedWord;

        final String committedWordString = committedWord.toString();

        final int cancelLength = committedWord.length();

        // We want java chars, not codepoints for the following.

        final int separatorLength = mLastComposedWord.mSeparatorString.length();
@@ -1376,34 +1377,45 @@ public final class InputLogic { 
        if (!TextUtils.isEmpty(previousWord) && !TextUtils.isEmpty(committedWord)) {

            if (mSuggest != null) {

                mSuggest.mDictionaryFacilitator.cancelAddingUserHistory(

                        previousWord, committedWord.toString());

                        previousWord, committedWordString);

            }

        }

        final String stringToCommit = originallyTypedWord + mLastComposedWord.mSeparatorString;

        final SpannableString textToCommit = new SpannableString(stringToCommit);

        if (committedWord instanceof SpannableString) {

            final int lastCharIndex = textToCommit.length() - 1;

            // Add the auto-correction to the list of suggestions.

            textToCommit.setSpan(new SuggestionSpan(settingsValues.mLocale,

                    new String[] { committedWord.toString() }, 0 /* flags */),

                    0 /* start */, lastCharIndex /* end */, 0 /* flags */);

            final SpannableString committedWordWithSuggestionSpans = (SpannableString)committedWord;

            final Object[] spans = committedWordWithSuggestionSpans.getSpans(0,

                    committedWord.length(), Object.class);

            final int lastCharIndex = textToCommit.length() - 1;

            // We will collect all suggestions in the following array.

            final ArrayList<String> suggestions = CollectionUtils.newArrayList();

            // First, add the committed word to the list of suggestions.

            suggestions.add(committedWordString);

            for (final Object span : spans) {

                // Put all the spans in the original text on this new text. We could remove the

                // typed word from the suggestions, but we'd have to make more dynamic instanceof

                // checks, to copy the span, copy all suggestions and attributes... And there is

                // the risk to drop the originally typed string if there is a subtle bug. There is

                // still the committed auto-correction that we reverted from, which is not included

                // in the suggestions, that's why we added it with another call to setSpan a few

                // lines above.

                // The code that re-reads these spans already knows to do the right thing whether

                // the typed word is included or not. That should be enough.

                // If this is a suggestion span, we check that the locale is the right one, and

                // that the word is not the committed word. That should mostly be the case.

                // Given this, we add it to the list of suggestions, otherwise we discard it.

                if (span instanceof SuggestionSpan) {

                    final SuggestionSpan suggestionSpan = (SuggestionSpan)span;

                    if (!suggestionSpan.getLocale().equals(settingsValues.mLocale.toString())) {

                        continue;

                    }

                    for (final String suggestion : suggestionSpan.getSuggestions()) {

                        if (!suggestion.equals(committedWordString)) {

                            suggestions.add(suggestion);

                        }

                    }

                } else {

                    // If this is not a suggestion span, we just add it as is.

                    textToCommit.setSpan(span, 0 /* start */, lastCharIndex /* end */,

                            committedWordWithSuggestionSpans.getSpanFlags(span));

                }

            }

            // Add the suggestion list to the list of suggestions.

            textToCommit.setSpan(new SuggestionSpan(settingsValues.mLocale,

                    suggestions.toArray(new String[suggestions.size()]), 0 /* flags */),

                    0 /* start */, lastCharIndex /* end */, 0 /* flags */);

        }

        if (settingsValues.mSpacingAndPunctuations.mCurrentLanguageHasSpaces) {

            // For languages with spaces, we revert to the typed string, but the cursor is still

            // after the separator so we don't resume suggestions. If the user wants to correct

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

+2 −2
Original line number Diff line number Diff line
@@ -80,8 +80,8 @@ public class BlueUnderlineTests extends InputTestsBase { 
        sleep(DELAY_TO_WAIT_FOR_UNDERLINE);

        runMessages();

        final SpanGetter suggestionSpan = new SpanGetter(mEditText.getText(), SuggestionSpan.class);

        assertEquals("show no blue underline after backspace, span start should be -1",

                EXPECTED_SUGGESTION_SPAN_START, suggestionSpan.mStart);

        assertFalse("show no blue underline after backspace, span start should be -1",

                suggestionSpan.isAutoCorrectionIndicator());

        final SpanGetter underlineSpan = new SpanGetter(mEditText.getText(), UnderlineSpan.class);

        assertEquals("should be composing, so should have an underline span",

                EXPECTED_UNDERLINE_SPAN_START, underlineSpan.mStart);