Merge RichInputConnection with EditingUtils

Change-Id: I9982ff325bef56694402caef28a77683c52ccd71

java/src/com/android/inputmethod/latin/EditingUtils.java

@@ -1,218 +0,0 @@
-/*
- * Copyright (C) 2009 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.view.inputmethod.ExtractedText;
-import android.view.inputmethod.ExtractedTextRequest;
-import android.view.inputmethod.InputConnection;
-
-import java.util.regex.Pattern;
-
-/**
- * Utility methods to deal with editing text through an InputConnection.
- */
-public class EditingUtils {
-    /**
-     * Number of characters we want to look back in order to identify the previous word
-     */
-    // Provision for a long word pair and a separator
-    private static final int LOOKBACK_CHARACTER_NUM = BinaryDictionary.MAX_WORD_LENGTH * 2 + 1;
-    private static final int INVALID_CURSOR_POSITION = -1;
-
-    private EditingUtils() {
-        // Unintentional empty constructor for singleton.
-    }
-
-    private static int getCursorPosition(InputConnection connection) {
-        if (null == connection) return INVALID_CURSOR_POSITION;
-        final ExtractedText extracted = connection.getExtractedText(new ExtractedTextRequest(), 0);
-        if (extracted == null) {
-            return INVALID_CURSOR_POSITION;
-        }
-        return extracted.startOffset + extracted.selectionStart;
-    }
-
-    /**
-     * @param connection connection to the current text field.
-     * @param separators characters which may separate words
-     * @return the word that surrounds the cursor, including up to one trailing
-     *   separator. For example, if the field contains "he|llo world", where |
-     *   represents the cursor, then "hello " will be returned.
-     */
-    public static String getWordAtCursor(InputConnection connection, String separators) {
-        // getWordRangeAtCursor returns null if the connection is null
-        Range r = getWordRangeAtCursor(connection, separators, 0);
-        return (r == null) ? null : r.mWord;
-    }
-
-    /**
-     * Represents a range of text, relative to the current cursor position.
-     */
-    public static class Range {
-        /** Characters before selection start */
-        public final int mCharsBefore;
-
-        /**
-         * Characters after selection start, including one trailing word
-         * separator.
-         */
-        public final int mCharsAfter;
-
-        /** The actual characters that make up a word */
-        public final String mWord;
-
-        public Range(int charsBefore, int charsAfter, String word) {
-            if (charsBefore < 0 || charsAfter < 0) {
-                throw new IndexOutOfBoundsException();
-            }
-            this.mCharsBefore = charsBefore;
-            this.mCharsAfter = charsAfter;
-            this.mWord = word;
-        }
-    }
-
-    /**
-     * Returns the text surrounding the cursor.
-     *
-     * @param connection the InputConnection to the TextView
-     * @param sep a string of characters that split words.
-     * @param additionalPrecedingWordsCount the number of words before the current word that should
-     *   be included in the returned range
-     * @return a range containing the text surrounding the cursor
-     */
-    public static Range getWordRangeAtCursor(InputConnection connection, String sep,
-            int additionalPrecedingWordsCount) {
-        if (connection == null || sep == null) {
-            return null;
-        }
-        CharSequence before = connection.getTextBeforeCursor(1000, 0);
-        CharSequence after = connection.getTextAfterCursor(1000, 0);
-        if (before == null || after == null) {
-            return null;
-        }
-
-        // Going backward, alternate skipping non-separators and separators until enough words
-        // have been read.
-        int start = before.length();
-        boolean isStoppingAtWhitespace = true;  // toggles to indicate what to stop at
-        while (true) { // see comments below for why this is guaranteed to halt
-            while (start > 0) {
-                final int codePoint = Character.codePointBefore(before, start);
-                if (isStoppingAtWhitespace == isSeparator(codePoint, sep)) {
-                    break;  // inner loop
-                }
-                --start;
-                if (Character.isSupplementaryCodePoint(codePoint)) {
-                    --start;
-                }
-            }
-            // isStoppingAtWhitespace is true every other time through the loop,
-            // so additionalPrecedingWordsCount is guaranteed to become < 0, which
-            // guarantees outer loop termination
-            if (isStoppingAtWhitespace && (--additionalPrecedingWordsCount < 0)) {
-                break;  // outer loop
-            }
-            isStoppingAtWhitespace = !isStoppingAtWhitespace;
-        }
-
-        // Find last word separator after the cursor
-        int end = -1;
-        while (++end < after.length()) {
-            final int codePoint = Character.codePointAt(after, end);
-            if (isSeparator(codePoint, sep)) {
-                break;
-            }
-            if (Character.isSupplementaryCodePoint(codePoint)) {
-                ++end;
-            }
-        }
-
-        int cursor = getCursorPosition(connection);
-        if (start >= 0 && cursor + end <= after.length() + before.length()) {
-            String word = before.toString().substring(start, before.length())
-                    + after.toString().substring(0, end);
-            return new Range(before.length() - start, end, word);
-        }
-
-        return null;
-    }
-
-    private static boolean isSeparator(int code, String sep) {
-        return sep.indexOf(code) != -1;
-    }
-
-    private static final Pattern spaceRegex = Pattern.compile("\\s+");
-
-    public static CharSequence getPreviousWord(InputConnection connection,
-            String sentenceSeperators) {
-        //TODO: Should fix this. This could be slow!
-        if (null == connection) return null;
-        CharSequence prev = connection.getTextBeforeCursor(LOOKBACK_CHARACTER_NUM, 0);
-        return getPreviousWord(prev, sentenceSeperators);
-    }
-
-    // Get the word before the whitespace preceding the non-whitespace preceding the cursor.
-    // Also, it won't return words that end in a separator.
-    // Example :
-    // "abc def|" -> abc
-    // "abc def |" -> abc
-    // "abc def. |" -> abc
-    // "abc def . |" -> def
-    // "abc|" -> null
-    // "abc |" -> null
-    // "abc. def|" -> null
-    public static CharSequence getPreviousWord(CharSequence prev, String sentenceSeperators) {
-        if (prev == null) return null;
-        String[] w = spaceRegex.split(prev);
-
-        // If we can't find two words, or we found an empty word, return null.
-        if (w.length < 2 || w[w.length - 2].length() <= 0) return null;
-
-        // If ends in a separator, return null
-        char lastChar = w[w.length - 2].charAt(w[w.length - 2].length() - 1);
-        if (sentenceSeperators.contains(String.valueOf(lastChar))) return null;
-
-        return w[w.length - 2];
-    }
-
-    public static CharSequence getThisWord(InputConnection connection, String sentenceSeperators) {
-        if (null == connection) return null;
-        final CharSequence prev = connection.getTextBeforeCursor(LOOKBACK_CHARACTER_NUM, 0);
-        return getThisWord(prev, sentenceSeperators);
-    }
-
-    // Get the word immediately before the cursor, even if there is whitespace between it and
-    // the cursor - but not if there is punctuation.
-    // Example :
-    // "abc def|" -> def
-    // "abc def |" -> def
-    // "abc def. |" -> null
-    // "abc def . |" -> null
-    public static CharSequence getThisWord(CharSequence prev, String sentenceSeperators) {
-        if (prev == null) return null;
-        String[] w = spaceRegex.split(prev);
-
-        // No word : return null
-        if (w.length < 1 || w[w.length - 1].length() <= 0) return null;
-
-        // If ends in a separator, return null
-        char lastChar = w[w.length - 1].charAt(w[w.length - 1].length() - 1);
-        if (sentenceSeperators.contains(String.valueOf(lastChar))) return null;
-
-        return w[w.length - 1];
-    }
-}

java/src/com/android/inputmethod/latin/LatinIME.java

@@ -783,7 +783,7 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
             ResearchLogger.latinIME_onUpdateSelection(mLastSelectionStart, mLastSelectionEnd,
                     oldSelStart, oldSelEnd, newSelStart, newSelEnd, composingSpanStart,
                     composingSpanEnd, mExpectingUpdateSelection,
-                    expectingUpdateSelectionFromLogger, getCurrentInputConnection());
+                    expectingUpdateSelectionFromLogger, mConnection);
             if (expectingUpdateSelectionFromLogger) {
                 return;
             }
@@ -1760,11 +1760,7 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
         }
 
         // TODO: May need a better way of retrieving previous word
-        final CharSequence prevWord;
+        final CharSequence prevWord = mConnection.getPreviousWord(mSettingsValues.mWordSeparators);
-        // TODO: move getPreviousWord to AutoInputConnection
-        prevWord = EditingUtils.getPreviousWord(mConnection.getInputConnection(),
-                mSettingsValues.mWordSeparators);
-
         final CharSequence typedWord = mWordComposer.getTypedWord();
         // getSuggestedWords handles gracefully a null value of prevWord
         final SuggestedWords suggestedWords = mSuggest.getSuggestedWords(mWordComposer,
@@ -1993,8 +1989,7 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
 
         final SuggestedWords suggestedWords;
         if (mCorrectionMode == Suggest.CORRECTION_FULL_BIGRAM) {
-            final CharSequence prevWord = EditingUtils.getThisWord(getCurrentInputConnection(),
+            final CharSequence prevWord = mConnection.getThisWord(mSettingsValues.mWordSeparators);
-                    mSettingsValues.mWordSeparators);
             if (!TextUtils.isEmpty(prevWord)) {
                 suggestedWords = mSuggest.getBigramPredictions(prevWord);
             } else {
@@ -2031,10 +2026,8 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
         }
 
         if (mUserHistoryDictionary != null) {
-            final CharSequence prevWord;
+            final CharSequence prevWord
-            // TODO: move getPreviousWord to AutoInputConnection
+                    = mConnection.getPreviousWord(mSettingsValues.mWordSeparators);
-            prevWord = EditingUtils.getPreviousWord(mConnection.getInputConnection(),
-                    mSettingsValues.mWordSeparators);
             final String secondWord;
             if (mWordComposer.isAutoCapitalized() && !mWordComposer.isMostlyCaps()) {
                 secondWord = suggestion.toString().toLowerCase(
@@ -2093,9 +2086,7 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
 
         // Bail out if word before cursor is 0-length or a single non letter (like an apostrophe)
         // Example: " -|" gets rejected here but "e-|" and "e|" are okay
-        // TODO: move getWordAtCursor inside AutoInputConnection
+        CharSequence word = mConnection.getWordAtCursor(mSettingsValues.mWordSeparators);
-        CharSequence word = EditingUtils.getWordAtCursor(mConnection.getInputConnection(),
-                mSettingsValues.mWordSeparators);
         // We don't suggest on leading single quotes, so we have to remove them from the word if
         // it starts with single quotes.
         while (!TextUtils.isEmpty(word) && Keyboard.CODE_SINGLE_QUOTE == word.charAt(0)) {

java/src/com/android/inputmethod/latin/ResearchLogger.java

@@ -612,12 +612,13 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang
             final int lastSelectionEnd, final int oldSelStart, final int oldSelEnd,
             final int newSelStart, final int newSelEnd, final int composingSpanStart,
             final int composingSpanEnd, final boolean expectingUpdateSelection,
-            final boolean expectingUpdateSelectionFromLogger, final InputConnection connection) {
+            final boolean expectingUpdateSelectionFromLogger,
+            final RichInputConnection connection) {
         final Object[] values = {
             lastSelectionStart, lastSelectionEnd, oldSelStart, oldSelEnd, newSelStart,
             newSelEnd, composingSpanStart, composingSpanEnd, expectingUpdateSelection,
             expectingUpdateSelectionFromLogger,
-            EditingUtils.getWordRangeAtCursor(connection, WHITESPACE_SEPARATORS, 1).mWord
+            connection.getWordRangeAtCursor(WHITESPACE_SEPARATORS, 1).mWord
         };
         getInstance().writeEvent(EVENTKEYS_LATINIME_ONUPDATESELECTION, values);
     }

java/src/com/android/inputmethod/latin/RichInputConnection.java

@@ -20,14 +20,23 @@ import android.util.Log;
 import android.view.KeyEvent;
 import android.view.inputmethod.CompletionInfo;
 import android.view.inputmethod.CorrectionInfo;
+import android.view.inputmethod.ExtractedText;
+import android.view.inputmethod.ExtractedTextRequest;
 import android.view.inputmethod.InputConnection;
 
+import java.util.regex.Pattern;
+
 /**
  * Wrapper for InputConnection to simplify interaction
  */
 public class RichInputConnection {
     private static final String TAG = RichInputConnection.class.getSimpleName();
     private static final boolean DBG = false;
+    // Provision for a long word pair and a separator
+    private static final int LOOKBACK_CHARACTER_NUM = BinaryDictionary.MAX_WORD_LENGTH * 2 + 1;
+    private static final Pattern spaceRegex = Pattern.compile("\\s+");
+    private static final int INVALID_CURSOR_POSITION = -1;
+
     InputConnection mIC;
     int mNestLevel;
     public RichInputConnection() {
@@ -35,11 +44,6 @@ public class RichInputConnection {
         mNestLevel = 0;
     }
 
-    // TODO: remove this method - the whole point of this class is void if mIC is escaping
-    public InputConnection getInputConnection() {
-        return mIC;
-    }
-
     public void beginBatchEdit(final InputConnection newInputConnection) {
         if (++mNestLevel == 1) {
             mIC = newInputConnection;
@@ -119,4 +123,178 @@ public class RichInputConnection {
         if (mNestLevel <= 0) Log.e(TAG, "Batch edit not in progress!"); // TODO: exception instead
         if (null != mIC) mIC.commitCompletion(completionInfo);
     }
+
+    public CharSequence getPreviousWord(final String sentenceSeperators) {
+        //TODO: Should fix this. This could be slow!
+        if (null == mIC) return null;
+        CharSequence prev = mIC.getTextBeforeCursor(LOOKBACK_CHARACTER_NUM, 0);
+        return getPreviousWord(prev, sentenceSeperators);
+    }
+
+    /**
+     * Represents a range of text, relative to the current cursor position.
+     */
+    public static class Range {
+        /** Characters before selection start */
+        public final int mCharsBefore;
+
+        /**
+         * Characters after selection start, including one trailing word
+         * separator.
+         */
+        public final int mCharsAfter;
+
+        /** The actual characters that make up a word */
+        public final String mWord;
+
+        public Range(int charsBefore, int charsAfter, String word) {
+            if (charsBefore < 0 || charsAfter < 0) {
+                throw new IndexOutOfBoundsException();
+            }
+            this.mCharsBefore = charsBefore;
+            this.mCharsAfter = charsAfter;
+            this.mWord = word;
+        }
+    }
+
+    private static boolean isSeparator(int code, String sep) {
+        return sep.indexOf(code) != -1;
+    }
+
+    // Get the word before the whitespace preceding the non-whitespace preceding the cursor.
+    // Also, it won't return words that end in a separator.
+    // Example :
+    // "abc def|" -> abc
+    // "abc def |" -> abc
+    // "abc def. |" -> abc
+    // "abc def . |" -> def
+    // "abc|" -> null
+    // "abc |" -> null
+    // "abc. def|" -> null
+    public static CharSequence getPreviousWord(CharSequence prev, String sentenceSeperators) {
+        if (prev == null) return null;
+        String[] w = spaceRegex.split(prev);
+
+        // If we can't find two words, or we found an empty word, return null.
+        if (w.length < 2 || w[w.length - 2].length() <= 0) return null;
+
+        // If ends in a separator, return null
+        char lastChar = w[w.length - 2].charAt(w[w.length - 2].length() - 1);
+        if (sentenceSeperators.contains(String.valueOf(lastChar))) return null;
+
+        return w[w.length - 2];
+    }
+
+    public CharSequence getThisWord(String sentenceSeperators) {
+        if (null == mIC) return null;
+        final CharSequence prev = mIC.getTextBeforeCursor(LOOKBACK_CHARACTER_NUM, 0);
+        return getThisWord(prev, sentenceSeperators);
+    }
+
+    // Get the word immediately before the cursor, even if there is whitespace between it and
+    // the cursor - but not if there is punctuation.
+    // Example :
+    // "abc def|" -> def
+    // "abc def |" -> def
+    // "abc def. |" -> null
+    // "abc def . |" -> null
+    public static CharSequence getThisWord(CharSequence prev, String sentenceSeperators) {
+        if (prev == null) return null;
+        String[] w = spaceRegex.split(prev);
+
+        // No word : return null
+        if (w.length < 1 || w[w.length - 1].length() <= 0) return null;
+
+        // If ends in a separator, return null
+        char lastChar = w[w.length - 1].charAt(w[w.length - 1].length() - 1);
+        if (sentenceSeperators.contains(String.valueOf(lastChar))) return null;
+
+        return w[w.length - 1];
+    }
+
+    /**
+     * @param separators characters which may separate words
+     * @return the word that surrounds the cursor, including up to one trailing
+     *   separator. For example, if the field contains "he|llo world", where |
+     *   represents the cursor, then "hello " will be returned.
+     */
+    public String getWordAtCursor(String separators) {
+        // getWordRangeAtCursor returns null if the connection is null
+        Range r = getWordRangeAtCursor(separators, 0);
+        return (r == null) ? null : r.mWord;
+    }
+
+    private int getCursorPosition() {
+        if (null == mIC) return INVALID_CURSOR_POSITION;
+        final ExtractedText extracted = mIC.getExtractedText(new ExtractedTextRequest(), 0);
+        if (extracted == null) {
+            return INVALID_CURSOR_POSITION;
+        }
+        return extracted.startOffset + extracted.selectionStart;
+    }
+
+    /**
+     * Returns the text surrounding the cursor.
+     *
+     * @param sep a string of characters that split words.
+     * @param additionalPrecedingWordsCount the number of words before the current word that should
+     *   be included in the returned range
+     * @return a range containing the text surrounding the cursor
+     */
+    public Range getWordRangeAtCursor(String sep, int additionalPrecedingWordsCount) {
+        if (mIC == null || sep == null) {
+            return null;
+        }
+        CharSequence before = mIC.getTextBeforeCursor(1000, 0);
+        CharSequence after = mIC.getTextAfterCursor(1000, 0);
+        if (before == null || after == null) {
+            return null;
+        }
+
+        // Going backward, alternate skipping non-separators and separators until enough words
+        // have been read.
+        int start = before.length();
+        boolean isStoppingAtWhitespace = true;  // toggles to indicate what to stop at
+        while (true) { // see comments below for why this is guaranteed to halt
+            while (start > 0) {
+                final int codePoint = Character.codePointBefore(before, start);
+                if (isStoppingAtWhitespace == isSeparator(codePoint, sep)) {
+                    break;  // inner loop
+                }
+                --start;
+                if (Character.isSupplementaryCodePoint(codePoint)) {
+                    --start;
+                }
+            }
+            // isStoppingAtWhitespace is true every other time through the loop,
+            // so additionalPrecedingWordsCount is guaranteed to become < 0, which
+            // guarantees outer loop termination
+            if (isStoppingAtWhitespace && (--additionalPrecedingWordsCount < 0)) {
+                break;  // outer loop
+            }
+            isStoppingAtWhitespace = !isStoppingAtWhitespace;
+        }
+
+        // Find last word separator after the cursor
+        int end = -1;
+        while (++end < after.length()) {
+            final int codePoint = Character.codePointAt(after, end);
+            if (isSeparator(codePoint, sep)) {
+                break;
+            }
+            if (Character.isSupplementaryCodePoint(codePoint)) {
+                ++end;
+            }
+        }
+
+        int cursor = getCursorPosition();
+        if (start >= 0 && cursor + end <= after.length() + before.length()) {
+            String word = before.toString().substring(start, before.length())
+                    + after.toString().substring(0, end);
+            return new Range(before.length() - start, end, word);
+        }
+
+        return null;
+    }
+
 }

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

@@ -22,9 +22,9 @@ import android.view.inputmethod.ExtractedTextRequest;
 import android.view.inputmethod.InputConnection;
 import android.view.inputmethod.InputConnectionWrapper;
 
-import com.android.inputmethod.latin.EditingUtils.Range;
+import com.android.inputmethod.latin.RichInputConnection.Range;
 
-public class EditingUtilsTests extends AndroidTestCase {
+public class RichInputConnectionTests extends AndroidTestCase {
 
     // The following is meant to be a reasonable default for
     // the "word_separators" resource.
@@ -64,12 +64,23 @@ public class EditingUtilsTests extends AndroidTestCase {
         }
 
         /* (non-Javadoc)
-         * @see android.view.inputmethod.InputConnectionWrapper#getExtractedText(ExtractedTextRequest, int)
+         * @see android.view.inputmethod.InputConnectionWrapper#getExtractedText(
+         *         ExtractedTextRequest, int)
          */
         @Override
         public ExtractedText getExtractedText(ExtractedTextRequest request, int flags) {
             return mExtractedText;
         }
+
+        @Override
+        public boolean beginBatchEdit() {
+            return true;
+        }
+
+        @Override
+        public boolean endBatchEdit() {
+            return true;
+        }
     }
 
     /************************** Tests ************************/
@@ -79,31 +90,31 @@ public class EditingUtilsTests extends AndroidTestCase {
      */
     public void testGetPreviousWord() {
         // If one of the following cases breaks, the bigram suggestions won't work.
-        assertEquals(EditingUtils.getPreviousWord("abc def", sSeparators), "abc");
+        assertEquals(RichInputConnection.getPreviousWord("abc def", sSeparators), "abc");
-        assertNull(EditingUtils.getPreviousWord("abc", sSeparators));
+        assertNull(RichInputConnection.getPreviousWord("abc", sSeparators));
-        assertNull(EditingUtils.getPreviousWord("abc. def", sSeparators));
+        assertNull(RichInputConnection.getPreviousWord("abc. def", sSeparators));
 
         // The following tests reflect the current behavior of the function
-        // EditingUtils#getPreviousWord.
+        // RichInputConnection#getPreviousWord.
         // TODO: However at this time, the code does never go
         // into such a path, so it should be safe to change the behavior of
         // this function if needed - especially since it does not seem very
         // logical. These tests are just there to catch any unintentional
-        // changes in the behavior of the EditingUtils#getPreviousWord method.
+        // changes in the behavior of the RichInputConnection#getPreviousWord method.
-        assertEquals(EditingUtils.getPreviousWord("abc def ", sSeparators), "abc");
+        assertEquals(RichInputConnection.getPreviousWord("abc def ", sSeparators), "abc");
-        assertEquals(EditingUtils.getPreviousWord("abc def.", sSeparators), "abc");
+        assertEquals(RichInputConnection.getPreviousWord("abc def.", sSeparators), "abc");
-        assertEquals(EditingUtils.getPreviousWord("abc def .", sSeparators), "def");
+        assertEquals(RichInputConnection.getPreviousWord("abc def .", sSeparators), "def");
-        assertNull(EditingUtils.getPreviousWord("abc ", sSeparators));
+        assertNull(RichInputConnection.getPreviousWord("abc ", sSeparators));
     }
 
     /**
      * Test for getting the word before the cursor (for bigram)
      */
     public void testGetThisWord() {
-        assertEquals(EditingUtils.getThisWord("abc def", sSeparators), "def");
+        assertEquals(RichInputConnection.getThisWord("abc def", sSeparators), "def");
-        assertEquals(EditingUtils.getThisWord("abc def ", sSeparators), "def");
+        assertEquals(RichInputConnection.getThisWord("abc def ", sSeparators), "def");
-        assertNull(EditingUtils.getThisWord("abc def.", sSeparators));
+        assertNull(RichInputConnection.getThisWord("abc def.", sSeparators));
-        assertNull(EditingUtils.getThisWord("abc def .", sSeparators));
+        assertNull(RichInputConnection.getThisWord("abc def .", sSeparators));
     }
 
     /**
@@ -111,51 +122,57 @@ public class EditingUtilsTests extends AndroidTestCase {
      */
     public void testGetWordRangeAtCursor() {
         ExtractedText et = new ExtractedText();
+        final RichInputConnection ic = new RichInputConnection();
         InputConnection mockConnection;
         mockConnection = new MockConnection("word wo", "rd", et);
         et.startOffset = 0;
         et.selectionStart = 7;
         Range r;
 
+        ic.beginBatchEdit(mockConnection);
         // basic case
-        r = EditingUtils.getWordRangeAtCursor(mockConnection, " ", 0);
+        r = ic.getWordRangeAtCursor(" ", 0);
         assertEquals("word", r.mWord);
-        r = null;
 
         // more than one word
-        r = EditingUtils.getWordRangeAtCursor(mockConnection, " ", 1);
+        r = ic.getWordRangeAtCursor(" ", 1);
         assertEquals("word word", r.mWord);
-        r = null;
+        ic.endBatchEdit();
 
         // tab character instead of space
         mockConnection = new MockConnection("one\tword\two", "rd", et);
-        r = EditingUtils.getWordRangeAtCursor(mockConnection, "\t", 1);
+        ic.beginBatchEdit(mockConnection);
+        r = ic.getWordRangeAtCursor("\t", 1);
+        ic.endBatchEdit();
         assertEquals("word\tword", r.mWord);
-        r = null;
 
         // only one word doesn't go too far
         mockConnection = new MockConnection("one\tword\two", "rd", et);
-        r = EditingUtils.getWordRangeAtCursor(mockConnection, "\t", 1);
+        ic.beginBatchEdit(mockConnection);
+        r = ic.getWordRangeAtCursor("\t", 1);
+        ic.endBatchEdit();
         assertEquals("word\tword", r.mWord);
-        r = null;
 
         // tab or space
         mockConnection = new MockConnection("one word\two", "rd", et);
-        r = EditingUtils.getWordRangeAtCursor(mockConnection, " \t", 1);
+        ic.beginBatchEdit(mockConnection);
+        r = ic.getWordRangeAtCursor(" \t", 1);
+        ic.endBatchEdit();
         assertEquals("word\tword", r.mWord);
-        r = null;
 
         // tab or space multiword
         mockConnection = new MockConnection("one word\two", "rd", et);
-        r = EditingUtils.getWordRangeAtCursor(mockConnection, " \t", 2);
+        ic.beginBatchEdit(mockConnection);
+        r = ic.getWordRangeAtCursor(" \t", 2);
+        ic.endBatchEdit();
         assertEquals("one word\tword", r.mWord);
-        r = null;
 
         // splitting on supplementary character
         final String supplementaryChar = "\uD840\uDC8A";
         mockConnection = new MockConnection("one word" + supplementaryChar + "wo", "rd", et);
-        r = EditingUtils.getWordRangeAtCursor(mockConnection, supplementaryChar, 0);
+        ic.beginBatchEdit(mockConnection);
+        r = ic.getWordRangeAtCursor(supplementaryChar, 0);
+        ic.endBatchEdit();
         assertEquals("word", r.mWord);
-        r = null;
     }
 }