path: root/src/test/java/com/anysoftkeyboard/TestableAnySoftKeyboard.java

package com.anysoftkeyboard;

import android.annotation.TargetApi;
import android.content.Context;
import android.os.Build;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.view.KeyEvent;
import android.view.View;
import android.view.inputmethod.CompletionInfo;
import android.view.inputmethod.CorrectionInfo;
import android.view.inputmethod.EditorInfo;
import android.view.inputmethod.ExtractedText;
import android.view.inputmethod.ExtractedTextRequest;
import android.view.inputmethod.InputConnection;

import com.anysoftkeyboard.addons.AddOn;
import com.anysoftkeyboard.base.dictionaries.WordComposer;
import com.anysoftkeyboard.dictionaries.DictionaryFactory;
import com.anysoftkeyboard.dictionaries.Suggest;
import com.anysoftkeyboard.dictionaries.UserDictionary;
import com.anysoftkeyboard.keyboards.AnyKeyboard;
import com.anysoftkeyboard.keyboards.GenericKeyboard;
import com.anysoftkeyboard.keyboards.Keyboard;
import com.anysoftkeyboard.keyboards.KeyboardAddOnAndBuilder;
import com.anysoftkeyboard.keyboards.KeyboardSwitcher;
import com.anysoftkeyboard.keyboards.views.AnyKeyboardView;
import com.anysoftkeyboard.keyboards.views.CandidateView;
import com.menny.android.anysoftkeyboard.R;
import com.menny.android.anysoftkeyboard.SoftKeyboard;

import org.junit.Assert;
import org.mockito.Mockito;
import org.robolectric.Robolectric;
import org.robolectric.shadows.ShadowSystemClock;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class TestableAnySoftKeyboard extends SoftKeyboard {

    private Suggest mSpiedSuggest;
    private TestableKeyboardSwitcher mSpiedKeyboardSwitcher;
    private AnyKeyboardView mSpiedKeyboardView;
    private EditorInfo mEditorInfo;
    private TestInputConnection mInputConnection;
    private CandidateView mMockCandidateView;
    private UserDictionary mSpiedUserDictionary;
    private boolean mHidden = true;

    public Suggest getSpiedSuggest() {
        return mSpiedSuggest;
    }

    public CandidateView getMockCandidateView() {
        return mMockCandidateView;
    }

    @NonNull
    @Override
    protected Suggest createSuggest() {
        Assert.assertNull(mSpiedSuggest);
        return mSpiedSuggest = Mockito.spy(new TestableSuggest(this));
    }

    public TestableKeyboardSwitcher getSpiedKeyboardSwitcher() {
        return mSpiedKeyboardSwitcher;
    }

    @Override
    public void onStartInput(EditorInfo attribute, boolean restarting) {
        mEditorInfo = attribute;
        if (restarting || mInputConnection == null) mInputConnection = Mockito.spy(new TestInputConnection(this));
        super.onStartInput(attribute, restarting);
    }

    @Override
    public View onCreateCandidatesView() {
        View spiedRootView = Mockito.spy(super.onCreateCandidatesView());
        mMockCandidateView = Mockito.mock(CandidateView.class);
        Mockito.doReturn(mMockCandidateView).when(spiedRootView).findViewById(R.id.candidates);
        return spiedRootView;
    }

    @Override
    public EditorInfo getCurrentInputEditorInfo() {
        return mEditorInfo;
    }

    @Override
    public InputConnection getCurrentInputConnection() {
        return mInputConnection;
    }

    @NonNull
    @Override
    protected KeyboardSwitcher createKeyboardSwitcher() {
        Assert.assertNull(mSpiedKeyboardSwitcher);
        return mSpiedKeyboardSwitcher = Mockito.spy(new TestableKeyboardSwitcher(this));
    }

    @Override
    public View onCreateInputView() {
        return mSpiedKeyboardView = Mockito.spy((AnyKeyboardView) super.onCreateInputView());
    }

    @Override
    public void onStartInputView(EditorInfo attribute, boolean restarting) {
        mHidden = false;
        super.onStartInputView(attribute, restarting);
    }

    @Override
    public void requestHideSelf(int flags) {
        mHidden = true;
        super.requestHideSelf(flags);
    }

    @Override
    public void hideWindow() {
        mHidden = true;
        super.hideWindow();
    }

    @Override
    protected void handleClose() {
        mHidden = true;
        super.handleClose();
    }

    public boolean isKeyboardViewHidden() {
        return mHidden;
    }

    public void simulateKeyPress(final int keyCode) {
        simulateKeyPress(keyCode, true);
    }

    public void simulateTextTyping(final String text) {
        simulateTextTyping(text, true, true);
    }

    public void simulateTextTyping(final String text, final boolean advanceTime, final boolean asDiscreteKeys) {
        if (asDiscreteKeys) {
            for (char key : text.toCharArray()) {
                simulateKeyPress(key, advanceTime);
                updateInputConnection(key);
            }
        } else {
            onText(null, text);
            Robolectric.flushForegroundThreadScheduler();
            if (advanceTime) ShadowSystemClock.sleep(25);
        }
    }

    public void updateInputConnection(char key) {
        mInputConnection.appendToInput(key);
    }

    public void simulateKeyPress(final int keyCode, final boolean advanceTime) {
        onPress(keyCode);
        Robolectric.flushForegroundThreadScheduler();
        final AnyKeyboard keyboard = getCurrentKeyboard();
        Assert.assertNotNull(keyboard);
        Keyboard.Key key = null;
        for (Keyboard.Key aKey : keyboard.getKeys()) {
            if (aKey.getPrimaryCode() == keyCode) {
                key = aKey;
                break;
            }
        }
        if (key == null) {
            onKey(keyCode, null, 0, new int[0], true);
        } else {
            onKey(keyCode, key, 0, keyboard.getNearestKeys(key.x + 5, key.y + 5), true);
        }
        Robolectric.flushForegroundThreadScheduler();
        if (advanceTime) ShadowSystemClock.sleep(25);
        onRelease(keyCode);
        Robolectric.flushForegroundThreadScheduler();
    }

    public static EditorInfo createEditorInfoTextWithSuggestions() {
        return createEditorInfo(EditorInfo.IME_ACTION_NONE, EditorInfo.TYPE_CLASS_TEXT);
    }

    public static EditorInfo createEditorInfo(final int imeOptions, final int inputType) {
        EditorInfo editorInfo = new EditorInfo();
        editorInfo.imeOptions = imeOptions;
        editorInfo.inputType = inputType;

        return editorInfo;
    }

    public static class TestableSuggest extends Suggest {

        private final Map<String, List<CharSequence>> mDefinedWords = new HashMap<>();
        private boolean mHasMinimalCorrection;

        public TestableSuggest(Context context) {
            super(context);
        }

        public void setSuggestionsForWord(String word, CharSequence... suggestions) {
            mDefinedWords.put(word.toLowerCase(), Arrays.asList(suggestions));
        }

        @NonNull
        @Override
        protected DictionaryFactory createDictionaryFactory() {
            return Mockito.spy(super.createDictionaryFactory());
        }

        @Override
        public List<CharSequence> getSuggestions(WordComposer wordComposer, boolean includeTypedWordIfValid) {
            String word = wordComposer.getTypedWord().toString().toLowerCase();

            ArrayList<CharSequence> suggestions = new ArrayList<>();
            suggestions.add(wordComposer.getTypedWord());
            if (mDefinedWords.containsKey(word)) {
                suggestions.addAll(mDefinedWords.get(word));
                mHasMinimalCorrection = true;
            } else {
                mHasMinimalCorrection = false;
            }

            return suggestions;
        }

        @Override
        public boolean hasMinimalCorrection() {
            return mHasMinimalCorrection;
        }
    }

    public static class TestableKeyboardSwitcher extends KeyboardSwitcher {

        public TestableKeyboardSwitcher(@NonNull AnySoftKeyboard ime) {
            super(ime);
        }

        @Override
        public /*was protected, now public*/ AnyKeyboard createKeyboardFromCreator(int mode, KeyboardAddOnAndBuilder creator) {
            return super.createKeyboardFromCreator(mode, creator);
        }

        @Override
        public /*was protected, now public*/ GenericKeyboard createGenericKeyboard(AddOn addOn, Context context, int layoutResId, int landscapeLayoutResId, String name, String keyboardId, int mode, boolean disableKeyPreview) {
            return super.createGenericKeyboard(addOn, context, layoutResId, landscapeLayoutResId, name, keyboardId, mode, disableKeyPreview);
        }
    }

    public static class TestInputConnection implements InputConnection {

        private int mCursorPosition = 0;
        private StringBuilder mInputText = new StringBuilder();
        @NonNull
        private final AnySoftKeyboard mIme;

        private String mLastCommitText = "";

        public TestInputConnection(@NonNull AnySoftKeyboard ime) {
            mIme = ime;
        }

        @Override
        public CharSequence getTextBeforeCursor(int n, int flags) {
            return mInputText.substring(Math.max(0, mCursorPosition - n), Math.min(mInputText.length(), mCursorPosition));
        }

        @Override
        public CharSequence getTextAfterCursor(int n, int flags) {
            return mInputText.substring(Math.max(0, mCursorPosition), Math.min(mInputText.length(), mCursorPosition + n));
        }

        @Override
        public CharSequence getSelectedText(int flags) {
            return "";
        }

        @Override
        public int getCursorCapsMode(int reqModes) {
            return 0;
        }

        @Override
        public ExtractedText getExtractedText(ExtractedTextRequest request, int flags) {
            ExtractedText extracted = new ExtractedText();
            extracted.startOffset = 0;
            extracted.selectionStart = mCursorPosition;
            extracted.selectionEnd = mCursorPosition;

            return extracted;
        }

        @Override
        public boolean deleteSurroundingText(int beforeLength, int afterLength) {
            //String beforeText = mInputText.substring(0, Math.min(mInputText.length(), mCursorPosition-beforeLength));
            //String afterText = mInputText.substring(mCursorPosition+afterLength);
            mInputText.delete(mCursorPosition-beforeLength, mCursorPosition+afterLength);// = beforeText+afterText;
            notifyTextChange(-beforeLength);
            return true;
        }

        private void notifyTextChange(int cursorDelta) {
            final int oldPosition = mCursorPosition;
            mCursorPosition += cursorDelta;
            mIme.onUpdateSelection(oldPosition, oldPosition, mCursorPosition, mCursorPosition, 0, mInputText.length());
        }

        @Override
        public boolean setComposingText(CharSequence text, int newCursorPosition) {
            return false;
        }

        @Override
        public boolean setComposingRegion(int start, int end) {
            return false;
        }

        @Override
        public boolean finishComposingText() {
            return false;
        }

        @Override
        public boolean commitText(CharSequence text, int newCursorPosition) {
            return true;
        }

        @Override
        public boolean commitCompletion(CompletionInfo text) {
            return false;
        }

        @TargetApi(Build.VERSION_CODES.HONEYCOMB)
        @Override
        public boolean commitCorrection(CorrectionInfo correctionInfo) {
            mLastCommitText = correctionInfo.getNewText().toString();
            return true;
        }

        public String getLastCommitText() {
            return mLastCommitText;
        }

        @Override
        public boolean setSelection(int start, int end) {
            if (start != mCursorPosition) {
                notifyTextChange(start-mCursorPosition);
            }

            return true;
        }

        @Override
        public boolean performEditorAction(int editorAction) {
            return false;
        }

        @Override
        public boolean performContextMenuAction(int id) {
            return false;
        }

        @Override
        public boolean beginBatchEdit() {
            return true;
        }

        @Override
        public boolean endBatchEdit() {
            return true;
        }

        @Override
        public boolean sendKeyEvent(KeyEvent event) {
            return true;
        }

        @Override
        public boolean clearMetaKeyStates(int states) {
            return true;
        }

        @Override
        public boolean reportFullscreenMode(boolean enabled) {
            return false;
        }

        @Override
        public boolean performPrivateCommand(String action, Bundle data) {
            return false;
        }

        @Override
        public boolean requestCursorUpdates(int cursorUpdateMode) {
            return false;
        }

        public void appendToInput(char key) {
            mInputText.insert(mCursorPosition, key);
            notifyTextChange(1);
        }
    }
}