tests/src/com/android/inputmethod/latin/InputTestsBase.java - platform/packages/inputmethods/LatinIME - Git at Google

 /*
  * Copyright (C) 2012 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 android.content.Context;
 import android.content.SharedPreferences;
 import android.os.Looper;
 import android.preference.PreferenceManager;
 import android.test.ServiceTestCase;
 import android.text.InputType;
 import android.text.SpannableStringBuilder;
 import android.text.style.CharacterStyle;
 import android.text.style.SuggestionSpan;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.inputmethod.EditorInfo;
 import android.view.inputmethod.InputConnection;
 import android.widget.EditText;
 import android.widget.FrameLayout;

 import com.android.inputmethod.keyboard.Key;
 import com.android.inputmethod.keyboard.Keyboard;
 import com.android.inputmethod.latin.SuggestedWords.SuggestedWordInfo;

 import java.util.Locale;

 public class InputTestsBase extends ServiceTestCase<LatinIMEForTests> {

     private static final String PREF_DEBUG_MODE = "debug_mode";

     // The message that sets the underline is posted with a 100 ms delay
     protected static final int DELAY_TO_WAIT_FOR_UNDERLINE = 200;

     protected LatinIME mLatinIME;
     protected Keyboard mKeyboard;
     protected MyEditText mEditText;
     protected View mInputView;
     protected InputConnection mInputConnection;

     // A helper class to ease span tests
     public static class SpanGetter {
         final SpannableStringBuilder mInputText;
         final CharacterStyle mSpan;
         final int mStart;
         final int mEnd;
         // The supplied CharSequence should be an instance of SpannableStringBuilder,
         // and it should contain exactly zero or one span. Otherwise, an exception
         // is thrown.
         public SpanGetter(final CharSequence inputText,
                 final Class<? extends CharacterStyle> spanType) {
             mInputText = (SpannableStringBuilder)inputText;
             final CharacterStyle[] spans =
                     mInputText.getSpans(0, mInputText.length(), spanType);
             if (0 == spans.length) {
                 mSpan = null;
                 mStart = -1;
                 mEnd = -1;
             } else if (1 == spans.length) {
                 mSpan = spans[0];
                 mStart = mInputText.getSpanStart(mSpan);
                 mEnd = mInputText.getSpanEnd(mSpan);
             } else {
                 throw new RuntimeException("Expected one span, found " + spans.length);
             }
         }
         public boolean isAutoCorrectionIndicator() {
             return (mSpan instanceof SuggestionSpan) &&
                     0 != (SuggestionSpan.FLAG_AUTO_CORRECTION & ((SuggestionSpan)mSpan).getFlags());
         }
         public String[] getSuggestions() {
             return ((SuggestionSpan)mSpan).getSuggestions();
         }
     }

     // A helper class to increase control over the EditText
     public static class MyEditText extends EditText {
         public Locale mCurrentLocale;
         public MyEditText(final Context c) {
             super(c);
         }

         @Override
         public void onAttachedToWindow() {
             // Make onAttachedToWindow "public"
             super.onAttachedToWindow();
         }

         // overriding hidden API in EditText
         public Locale getTextServicesLocale() {
             // This method is necessary because EditText is asking this method for the language
             // to check the spell in. If we don't override this, the spell checker will run in
             // whatever language the keyboard is currently set on the test device, ignoring any
             // settings we do inside the tests.
             return mCurrentLocale;
         }

         // overriding hidden API in EditText
         public Locale getSpellCheckerLocale() {
             // This method is necessary because EditText is asking this method for the language
             // to check the spell in. If we don't override this, the spell checker will run in
             // whatever language the keyboard is currently set on the test device, ignoring any
             // settings we do inside the tests.
             return mCurrentLocale;
         }

     }

     public InputTestsBase() {
         super(LatinIMEForTests.class);
     }

     // TODO: Isn't there a way to make this generic somehow? We can take a <T> and return a <T>
     // but we'd have to dispatch types on editor.put...() functions
     protected boolean setBooleanPreference(final String key, final boolean value,
             final boolean defaultValue) {
         final SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(mLatinIME);
         final boolean previousSetting = prefs.getBoolean(key, defaultValue);
         final SharedPreferences.Editor editor = prefs.edit();
         editor.putBoolean(key, value);
         editor.commit();
         return previousSetting;
     }

     // returns the previous setting value
     protected boolean setDebugMode(final boolean value) {
         return setBooleanPreference(PREF_DEBUG_MODE, value, false);
     }

     @Override
     protected void setUp() throws Exception {
         super.setUp();
         mEditText = new MyEditText(getContext());
         final int inputType = InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_FLAG_AUTO_CORRECT
                 | InputType.TYPE_TEXT_FLAG_MULTI_LINE;
         mEditText.setInputType(inputType);
         mEditText.setEnabled(true);
         setupService();
         mLatinIME = getService();
         final boolean previousDebugSetting = setDebugMode(true);
         mLatinIME.onCreate();
         setDebugMode(previousDebugSetting);
         final EditorInfo ei = new EditorInfo();
         final InputConnection ic = mEditText.onCreateInputConnection(ei);
         final LayoutInflater inflater =
                 (LayoutInflater)getContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE);
         final ViewGroup vg = new FrameLayout(getContext());
         mInputView = inflater.inflate(R.layout.input_view, vg);
         mLatinIME.onCreateInputMethodInterface().startInput(ic, ei);
         mLatinIME.setInputView(mInputView);
         mLatinIME.onBindInput();
         mLatinIME.onCreateInputView();
         mLatinIME.onStartInputView(ei, false);
         mInputConnection = ic;
         changeLanguage("en_US");
     }

     // We need to run the messages added to the handler from LatinIME. The only way to do
     // that is to call Looper#loop() on the right looper, so we're going to get the looper
     // object and call #loop() here. The messages in the handler actually run on the UI
     // thread of the keyboard by design of the handler, so we want to call it synchronously
     // on the same thread that the tests are running on to mimic the actual environment as
     // closely as possible.
     // Now, Looper#loop() never exits in normal operation unless the Looper#quit() method
     // is called, which has a lot of bad side effects. We can however just throw an exception
     // in the runnable which will unwind the stack and allow us to exit.
     private final class InterruptRunMessagesException extends RuntimeException {
         // Empty class
     }
     protected void runMessages() {
         mLatinIME.mHandler.post(new Runnable() {
                 @Override
                 public void run() {
                     throw new InterruptRunMessagesException();
                 }
             });
         try {
             Looper.loop();
         } catch (InterruptRunMessagesException e) {
             // Resume normal operation
         }
     }

     // type(int) and type(String): helper methods to send a code point resp. a string to LatinIME.
     protected void type(final int codePoint) {
         // onPressKey and onReleaseKey are explicitly deactivated here, but they do happen in the
         // code (although multitouch/slide input and other factors make the sequencing complicated).
         // They are supposed to be entirely deconnected from the input logic from LatinIME point of
         // view and only delegates to the parts of the code that care. So we don't include them here
         // to keep these tests as pinpoint as possible and avoid bringing it too many dependencies,
         // but keep them in mind if something breaks. Commenting them out as is should work.
         //mLatinIME.onPressKey(codePoint);
         for (final Key key : mKeyboard.mKeys) {
             if (key.mCode == codePoint) {
                 final int x = key.mX + key.mWidth / 2;
                 final int y = key.mY + key.mHeight / 2;
                 mLatinIME.onCodeInput(codePoint, x, y);
                 return;
             }
         }
         mLatinIME.onCodeInput(codePoint, Constants.NOT_A_COORDINATE, Constants.NOT_A_COORDINATE);
         //mLatinIME.onReleaseKey(codePoint, false);
     }

     protected void type(final String stringToType) {
         for (int i = 0; i < stringToType.length(); i = stringToType.offsetByCodePoints(i, 1)) {
             type(stringToType.codePointAt(i));
         }
     }

     protected void waitForDictionaryToBeLoaded() {
         int remainingAttempts = 300;
         while (remainingAttempts > 0 && mLatinIME.mSuggest.isCurrentlyWaitingForMainDictionary()) {
             try {
                 Thread.sleep(200);
             } catch (InterruptedException e) {
                 // Don't do much
             } finally {
                 --remainingAttempts;
             }
         }
         if (!mLatinIME.mSuggest.hasMainDictionary()) {
             throw new RuntimeException("Can't initialize the main dictionary");
         }
     }

     protected void changeLanguage(final String locale) {
         mEditText.mCurrentLocale = LocaleUtils.constructLocaleFromString(locale);
         SubtypeSwitcher.getInstance().forceLocale(mEditText.mCurrentLocale);
         mLatinIME.loadKeyboard();
         mKeyboard = mLatinIME.mKeyboardSwitcher.getKeyboard();
         waitForDictionaryToBeLoaded();
     }

     protected void pickSuggestionManually(final int index, final String suggestion) {
         mLatinIME.pickSuggestionManually(index, new SuggestedWordInfo(suggestion, 1,
                 SuggestedWordInfo.KIND_CORRECTION, "main"));
     }

     // Helper to avoid writing the try{}catch block each time
     protected static void sleep(final int milliseconds) {
         try {
             Thread.sleep(milliseconds);
         } catch (InterruptedException e) {}
     }
 }
	/*
	* Copyright (C) 2012 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 android.content.Context;
	import android.content.SharedPreferences;
	import android.os.Looper;
	import android.preference.PreferenceManager;
	import android.test.ServiceTestCase;
	import android.text.InputType;
	import android.text.SpannableStringBuilder;
	import android.text.style.CharacterStyle;
	import android.text.style.SuggestionSpan;
	import android.view.LayoutInflater;
	import android.view.View;
	import android.view.ViewGroup;
	import android.view.inputmethod.EditorInfo;
	import android.view.inputmethod.InputConnection;
	import android.widget.EditText;
	import android.widget.FrameLayout;

	import com.android.inputmethod.keyboard.Key;
	import com.android.inputmethod.keyboard.Keyboard;
	import com.android.inputmethod.latin.SuggestedWords.SuggestedWordInfo;

	import java.util.Locale;

	public class InputTestsBase extends ServiceTestCase<LatinIMEForTests> {

	private static final String PREF_DEBUG_MODE = "debug_mode";

	// The message that sets the underline is posted with a 100 ms delay
	protected static final int DELAY_TO_WAIT_FOR_UNDERLINE = 200;

	protected LatinIME mLatinIME;
	protected Keyboard mKeyboard;
	protected MyEditText mEditText;
	protected View mInputView;
	protected InputConnection mInputConnection;

	// A helper class to ease span tests
	public static class SpanGetter {
	final SpannableStringBuilder mInputText;
	final CharacterStyle mSpan;
	final int mStart;
	final int mEnd;
	// The supplied CharSequence should be an instance of SpannableStringBuilder,
	// and it should contain exactly zero or one span. Otherwise, an exception
	// is thrown.
	public SpanGetter(final CharSequence inputText,
	final Class<? extends CharacterStyle> spanType) {
	mInputText = (SpannableStringBuilder)inputText;
	final CharacterStyle[] spans =
	mInputText.getSpans(0, mInputText.length(), spanType);
	if (0 == spans.length) {
	mSpan = null;
	mStart = -1;
	mEnd = -1;
	} else if (1 == spans.length) {
	mSpan = spans[0];
	mStart = mInputText.getSpanStart(mSpan);
	mEnd = mInputText.getSpanEnd(mSpan);
	} else {
	throw new RuntimeException("Expected one span, found " + spans.length);
	}
	}
	public boolean isAutoCorrectionIndicator() {
	return (mSpan instanceof SuggestionSpan) &&
	0 != (SuggestionSpan.FLAG_AUTO_CORRECTION & ((SuggestionSpan)mSpan).getFlags());
	}
	public String[] getSuggestions() {
	return ((SuggestionSpan)mSpan).getSuggestions();
	}
	}

	// A helper class to increase control over the EditText
	public static class MyEditText extends EditText {
	public Locale mCurrentLocale;
	public MyEditText(final Context c) {
	super(c);
	}

	@Override
	public void onAttachedToWindow() {
	// Make onAttachedToWindow "public"
	super.onAttachedToWindow();
	}

	// overriding hidden API in EditText
	public Locale getTextServicesLocale() {
	// This method is necessary because EditText is asking this method for the language
	// to check the spell in. If we don't override this, the spell checker will run in
	// whatever language the keyboard is currently set on the test device, ignoring any
	// settings we do inside the tests.
	return mCurrentLocale;
	}

	// overriding hidden API in EditText
	public Locale getSpellCheckerLocale() {
	// This method is necessary because EditText is asking this method for the language
	// to check the spell in. If we don't override this, the spell checker will run in
	// whatever language the keyboard is currently set on the test device, ignoring any
	// settings we do inside the tests.
	return mCurrentLocale;
	}

	}

	public InputTestsBase() {
	super(LatinIMEForTests.class);
	}

	// TODO: Isn't there a way to make this generic somehow? We can take a <T> and return a <T>
	// but we'd have to dispatch types on editor.put...() functions
	protected boolean setBooleanPreference(final String key, final boolean value,
	final boolean defaultValue) {
	final SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(mLatinIME);
	final boolean previousSetting = prefs.getBoolean(key, defaultValue);
	final SharedPreferences.Editor editor = prefs.edit();
	editor.putBoolean(key, value);
	editor.commit();
	return previousSetting;
	}

	// returns the previous setting value
	protected boolean setDebugMode(final boolean value) {
	return setBooleanPreference(PREF_DEBUG_MODE, value, false);
	}

	@Override
	protected void setUp() throws Exception {
	super.setUp();
	mEditText = new MyEditText(getContext());
	final int inputType = InputType.TYPE_CLASS_TEXT \| InputType.TYPE_TEXT_FLAG_AUTO_CORRECT
	\| InputType.TYPE_TEXT_FLAG_MULTI_LINE;
	mEditText.setInputType(inputType);
	mEditText.setEnabled(true);
	setupService();
	mLatinIME = getService();
	final boolean previousDebugSetting = setDebugMode(true);
	mLatinIME.onCreate();
	setDebugMode(previousDebugSetting);
	final EditorInfo ei = new EditorInfo();
	final InputConnection ic = mEditText.onCreateInputConnection(ei);
	final LayoutInflater inflater =
	(LayoutInflater)getContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE);
	final ViewGroup vg = new FrameLayout(getContext());
	mInputView = inflater.inflate(R.layout.input_view, vg);
	mLatinIME.onCreateInputMethodInterface().startInput(ic, ei);
	mLatinIME.setInputView(mInputView);
	mLatinIME.onBindInput();
	mLatinIME.onCreateInputView();
	mLatinIME.onStartInputView(ei, false);
	mInputConnection = ic;
	changeLanguage("en_US");
	}

	// We need to run the messages added to the handler from LatinIME. The only way to do
	// that is to call Looper#loop() on the right looper, so we're going to get the looper
	// object and call #loop() here. The messages in the handler actually run on the UI
	// thread of the keyboard by design of the handler, so we want to call it synchronously
	// on the same thread that the tests are running on to mimic the actual environment as
	// closely as possible.
	// Now, Looper#loop() never exits in normal operation unless the Looper#quit() method
	// is called, which has a lot of bad side effects. We can however just throw an exception
	// in the runnable which will unwind the stack and allow us to exit.
	private final class InterruptRunMessagesException extends RuntimeException {
	// Empty class
	}
	protected void runMessages() {
	mLatinIME.mHandler.post(new Runnable() {
	@Override
	public void run() {
	throw new InterruptRunMessagesException();
	}
	});
	try {
	Looper.loop();
	} catch (InterruptRunMessagesException e) {
	// Resume normal operation
	}
	}

	// type(int) and type(String): helper methods to send a code point resp. a string to LatinIME.
	protected void type(final int codePoint) {
	// onPressKey and onReleaseKey are explicitly deactivated here, but they do happen in the
	// code (although multitouch/slide input and other factors make the sequencing complicated).
	// They are supposed to be entirely deconnected from the input logic from LatinIME point of
	// view and only delegates to the parts of the code that care. So we don't include them here
	// to keep these tests as pinpoint as possible and avoid bringing it too many dependencies,
	// but keep them in mind if something breaks. Commenting them out as is should work.
	//mLatinIME.onPressKey(codePoint);
	for (final Key key : mKeyboard.mKeys) {
	if (key.mCode == codePoint) {
	final int x = key.mX + key.mWidth / 2;
	final int y = key.mY + key.mHeight / 2;
	mLatinIME.onCodeInput(codePoint, x, y);
	return;
	}
	}
	mLatinIME.onCodeInput(codePoint, Constants.NOT_A_COORDINATE, Constants.NOT_A_COORDINATE);
	//mLatinIME.onReleaseKey(codePoint, false);
	}

	protected void type(final String stringToType) {
	for (int i = 0; i < stringToType.length(); i = stringToType.offsetByCodePoints(i, 1)) {
	type(stringToType.codePointAt(i));
	}
	}

	protected void waitForDictionaryToBeLoaded() {
	int remainingAttempts = 300;
	while (remainingAttempts > 0 && mLatinIME.mSuggest.isCurrentlyWaitingForMainDictionary()) {
	try {
	Thread.sleep(200);
	} catch (InterruptedException e) {
	// Don't do much
	} finally {
	--remainingAttempts;
	}
	}
	if (!mLatinIME.mSuggest.hasMainDictionary()) {
	throw new RuntimeException("Can't initialize the main dictionary");
	}
	}

	protected void changeLanguage(final String locale) {
	mEditText.mCurrentLocale = LocaleUtils.constructLocaleFromString(locale);
	SubtypeSwitcher.getInstance().forceLocale(mEditText.mCurrentLocale);
	mLatinIME.loadKeyboard();
	mKeyboard = mLatinIME.mKeyboardSwitcher.getKeyboard();
	waitForDictionaryToBeLoaded();
	}

	protected void pickSuggestionManually(final int index, final String suggestion) {
	mLatinIME.pickSuggestionManually(index, new SuggestedWordInfo(suggestion, 1,
	SuggestedWordInfo.KIND_CORRECTION, "main"));
	}

	// Helper to avoid writing the try{}catch block each time
	protected static void sleep(final int milliseconds) {
	try {
	Thread.sleep(milliseconds);
	} catch (InterruptedException e) {}
	}
	}