io.flutter.plugin.editing.ListenableEditingStateTest Class Reference

Classes
class	Listener

Public Member Functions
void	setUp ()
void	testConstructor ()
void	testBatchEditing ()
void	testBatchingEditing_callEndBeforeBegin ()
void	testBatchingEditing_addListenerDuringBatchEdit ()
void	testBatchingEditing_removeListenerDuringBatchEdit ()
void	testBatchingEditing_listenerCallsReplaceWhenBatchEditEnds ()
void	testSetComposingRegion ()
void	testClearBatchDeltas ()
void	testExtractBatchTextEditingDeltas ()
void	inputMethod_batchEditingBeginAndEnd ()
void	inputMethod_testSetSelection ()
void	inputMethod_testSetComposition ()
void	inputMethod_testCommitText ()

Package Attributes
KeyboardManager	mockKeyboardManager

Detailed Description

Definition at line 28 of file ListenableEditingStateTest.java.

Member Function Documentation

inputMethod_batchEditingBeginAndEnd()

void io.flutter.plugin.editing.ListenableEditingStateTest.inputMethod_batchEditingBeginAndEnd ( )

inline

Definition at line 259 of file ListenableEditingStateTest.java.

                                                    {
    final ArrayList<String> batchMarkers = new ArrayList<>();
    final ListenableEditingState editingState =
        new ListenableEditingState(null, new View(ctx)) {
          @Override
          public final void beginBatchEdit() {
            super.beginBatchEdit();
            batchMarkers.add("begin");
          }
 
          @Override
          public void endBatchEdit() {
            super.endBatchEdit();
            batchMarkers.add("end");
          }
        };
 
    final Listener listener = new Listener();
    final View testView = new View(ctx);
    final InputConnectionAdaptor inputConnection =
        new InputConnectionAdaptor(
            testView,
            0,
            mock(TextInputChannel.class),
            mockKeyboardManager,
            editingState,
            new EditorInfo());
 
    // Make sure begin/endBatchEdit is called on the Editable when the input method calls
    // InputConnection#begin/endBatchEdit.
    inputConnection.beginBatchEdit();
    assertEquals(1, batchMarkers.size());
    assertEquals("begin", batchMarkers.get(0));
 
    inputConnection.endBatchEdit();
    assertEquals(2, batchMarkers.size());
    assertEquals("end", batchMarkers.get(1));
  }

inputMethod_testCommitText()

void io.flutter.plugin.editing.ListenableEditingStateTest.inputMethod_testCommitText ( )

inline

Definition at line 393 of file ListenableEditingStateTest.java.

                                           {
    final ListenableEditingState editingState = new ListenableEditingState(null, new View(ctx));
    final Listener listener = new Listener();
    final View testView = new View(ctx);
    final InputConnectionAdaptor inputConnection =
        new InputConnectionAdaptor(
            testView,
            0,
            mock(TextInputChannel.class),
            mockKeyboardManager,
            editingState,
            new EditorInfo());
    editingState.replace(0, editingState.length(), "initial text");
 
    editingState.addEditingStateListener(listener);
  }

inputMethod_testSetComposition()

void io.flutter.plugin.editing.ListenableEditingStateTest.inputMethod_testSetComposition ( )

inline

Definition at line 333 of file ListenableEditingStateTest.java.

                                               {
    final ListenableEditingState editingState = new ListenableEditingState(null, new View(ctx));
    final Listener listener = new Listener();
    final View testView = new View(ctx);
    final InputConnectionAdaptor inputConnection =
        new InputConnectionAdaptor(
            testView,
            0,
            mock(TextInputChannel.class),
            mockKeyboardManager,
            editingState,
            new EditorInfo());
    editingState.replace(0, editingState.length(), "initial text");
 
    editingState.addEditingStateListener(listener);
 
    // setComposingRegion test.
    inputConnection.setComposingRegion(1, 3);
    assertTrue(listener.isCalled());
    assertFalse(listener.textChanged);
    assertFalse(listener.selectionChanged);
    assertTrue(listener.composingRegionChanged);
 
    Selection.setSelection(editingState, 0, 0);
    listener.reset();
 
    // setComposingText test: non-empty text, does not move cursor.
    inputConnection.setComposingText("composing", -1);
    assertTrue(listener.isCalled());
    assertTrue(listener.textChanged);
    assertFalse(listener.selectionChanged);
    assertTrue(listener.composingRegionChanged);
 
    listener.reset();
    // setComposingText test: non-empty text, moves cursor.
    inputConnection.setComposingText("composing2", 1);
    assertTrue(listener.isCalled());
    assertTrue(listener.textChanged);
    assertTrue(listener.selectionChanged);
    assertTrue(listener.composingRegionChanged);
 
    listener.reset();
    // setComposingText test: empty text.
    inputConnection.setComposingText("", 1);
    assertTrue(listener.isCalled());
    assertTrue(listener.textChanged);
    assertTrue(listener.selectionChanged);
    assertTrue(listener.composingRegionChanged);
 
    // finishComposingText test.
    inputConnection.setComposingText("composing text", 1);
    listener.reset();
    inputConnection.finishComposingText();
    assertTrue(listener.isCalled());
    assertFalse(listener.textChanged);
    assertFalse(listener.selectionChanged);
    assertTrue(listener.composingRegionChanged);
  }

inputMethod_testSetSelection()

void io.flutter.plugin.editing.ListenableEditingStateTest.inputMethod_testSetSelection ( )

inline

Definition at line 299 of file ListenableEditingStateTest.java.

                                             {
    final ListenableEditingState editingState = new ListenableEditingState(null, new View(ctx));
    final Listener listener = new Listener();
    final View testView = new View(ctx);
    final InputConnectionAdaptor inputConnection =
        new InputConnectionAdaptor(
            testView,
            0,
            mock(TextInputChannel.class),
            mockKeyboardManager,
            editingState,
            new EditorInfo());
    editingState.replace(0, editingState.length(), "initial text");
 
    editingState.addEditingStateListener(listener);
 
    inputConnection.setSelection(0, 0);
 
    assertTrue(listener.isCalled());
    assertFalse(listener.textChanged);
    assertTrue(listener.selectionChanged);
    assertFalse(listener.composingRegionChanged);
 
    listener.reset();
 
    inputConnection.setSelection(5, 5);
 
    assertTrue(listener.isCalled());
    assertFalse(listener.textChanged);
    assertTrue(listener.selectionChanged);
    assertFalse(listener.composingRegionChanged);
  }

setUp()

void io.flutter.plugin.editing.ListenableEditingStateTest.setUp ( )

inline

Definition at line 43 of file ListenableEditingStateTest.java.

                      {
    MockitoAnnotations.openMocks(this);
  }

testBatchEditing()

void io.flutter.plugin.editing.ListenableEditingStateTest.testBatchEditing ( )

inline

Definition at line 56 of file ListenableEditingStateTest.java.

                                 {
    final ListenableEditingState editingState = new ListenableEditingState(null, new View(ctx));
    final Listener listener = new Listener();
    final View testView = new View(ctx);
    final BaseInputConnection inputConnection = getTestInputConnection(testView, editingState);
 
    editingState.addEditingStateListener(listener);
 
    editingState.replace(0, editingState.length(), "update");
    assertTrue(listener.isCalled());
    assertTrue(listener.textChanged);
    assertFalse(listener.selectionChanged);
    assertFalse(listener.composingRegionChanged);
 
    assertEquals(-1, editingState.getSelectionStart());
    assertEquals(-1, editingState.getSelectionEnd());
 
    listener.reset();
 
    // Batch edit depth = 1.
    editingState.beginBatchEdit();
    editingState.replace(0, editingState.length(), "update1");
    assertFalse(listener.isCalled());
    // Batch edit depth = 2.
    editingState.beginBatchEdit();
    editingState.replace(0, editingState.length(), "update2");
    inputConnection.setComposingRegion(0, editingState.length());
    assertFalse(listener.isCalled());
    // Batch edit depth = 1.
    editingState.endBatchEdit();
    assertFalse(listener.isCalled());
 
    // Batch edit depth = 2.
    editingState.beginBatchEdit();
    assertFalse(listener.isCalled());
    inputConnection.setSelection(0, 0);
    assertFalse(listener.isCalled());
    // Batch edit depth = 1.
    editingState.endBatchEdit();
    assertFalse(listener.isCalled());
 
    // Remove composing region.
    inputConnection.finishComposingText();
 
    // Batch edit depth = 0. Last endBatchEdit.
    editingState.endBatchEdit();
 
    // Now notify the listener.
    assertTrue(listener.isCalled());
    assertTrue(listener.textChanged);
    assertFalse(listener.composingRegionChanged);
  }

testBatchingEditing_addListenerDuringBatchEdit()

void io.flutter.plugin.editing.ListenableEditingStateTest.testBatchingEditing_addListenerDuringBatchEdit ( )

inline

Definition at line 132 of file ListenableEditingStateTest.java.

                                                               {
    final ListenableEditingState editingState = new ListenableEditingState(null, new View(ctx));
    final Listener listener = new Listener();
 
    editingState.beginBatchEdit();
    editingState.addEditingStateListener(listener);
    editingState.replace(0, editingState.length(), "update");
    editingState.endBatchEdit();
 
    assertTrue(listener.isCalled());
    assertTrue(listener.textChanged);
    assertTrue(listener.selectionChanged);
    assertTrue(listener.composingRegionChanged);
 
    listener.reset();
 
    // Verifies the listener is officially added.
    editingState.replace(0, editingState.length(), "more updates");
    assertTrue(listener.isCalled());
    assertTrue(listener.textChanged);
    editingState.removeEditingStateListener(listener);
 
    listener.reset();
    // Now remove before endBatchEdit();
    editingState.beginBatchEdit();
    editingState.addEditingStateListener(listener);
    editingState.replace(0, editingState.length(), "update");
    editingState.removeEditingStateListener(listener);
    editingState.endBatchEdit();
 
    assertFalse(listener.isCalled());
  }

testBatchingEditing_callEndBeforeBegin()

void io.flutter.plugin.editing.ListenableEditingStateTest.testBatchingEditing_callEndBeforeBegin ( )

inline

Definition at line 110 of file ListenableEditingStateTest.java.

                                                       {
    final ListenableEditingState editingState = new ListenableEditingState(null, new View(ctx));
    final Listener listener = new Listener();
    editingState.addEditingStateListener(listener);
 
    editingState.endBatchEdit();
    assertFalse(listener.isCalled());
 
    editingState.replace(0, editingState.length(), "text");
    assertTrue(listener.isCalled());
    assertTrue(listener.textChanged);
 
    listener.reset();
    // Does not disrupt the followup events.
    editingState.beginBatchEdit();
    editingState.replace(0, editingState.length(), "more text");
    assertFalse(listener.isCalled());
    editingState.endBatchEdit();
    assertTrue(listener.isCalled());
  }

testBatchingEditing_listenerCallsReplaceWhenBatchEditEnds()

void io.flutter.plugin.editing.ListenableEditingStateTest.testBatchingEditing_listenerCallsReplaceWhenBatchEditEnds ( )

inline

Definition at line 180 of file ListenableEditingStateTest.java.

                                                                          {
    final ListenableEditingState editingState = new ListenableEditingState(null, new View(ctx));
 
    final Listener listener =
        new Listener() {
          @Override
          public void didChangeEditingState(
              boolean textChanged, boolean selectionChanged, boolean composingRegionChanged) {
            super.didChangeEditingState(textChanged, selectionChanged, composingRegionChanged);
            editingState.replace(
                0, editingState.length(), "one does not simply replace the text in the listener");
          }
        };
    editingState.addEditingStateListener(listener);
 
    editingState.beginBatchEdit();
    editingState.replace(0, editingState.length(), "update");
    editingState.endBatchEdit();
 
    assertTrue(listener.isCalled());
    assertEquals(1, listener.timesCalled);
    assertEquals("one does not simply replace the text in the listener", editingState.toString());
  }

testBatchingEditing_removeListenerDuringBatchEdit()

void io.flutter.plugin.editing.ListenableEditingStateTest.testBatchingEditing_removeListenerDuringBatchEdit ( )

inline

Definition at line 166 of file ListenableEditingStateTest.java.

                                                                  {
    final ListenableEditingState editingState = new ListenableEditingState(null, new View(ctx));
    final Listener listener = new Listener();
    editingState.addEditingStateListener(listener);
 
    editingState.beginBatchEdit();
    editingState.replace(0, editingState.length(), "update");
    editingState.removeEditingStateListener(listener);
    editingState.endBatchEdit();
 
    assertFalse(listener.isCalled());
  }

testClearBatchDeltas()

void io.flutter.plugin.editing.ListenableEditingStateTest.testClearBatchDeltas ( )

inline

Definition at line 235 of file ListenableEditingStateTest.java.

                                     {
    final ListenableEditingState editingState = new ListenableEditingState(null, new View(ctx));
    editingState.replace(0, editingState.length(), "text");
    editingState.delete(0, 1);
    editingState.insert(0, "This is t");
    editingState.clearBatchDeltas();
    assertEquals(0, editingState.extractBatchTextEditingDeltas().size());
  }

testConstructor()

void io.flutter.plugin.editing.ListenableEditingStateTest.testConstructor ( )

inline

Definition at line 48 of file ListenableEditingStateTest.java.

                                {
    // When provided valid composing range, should not fail
    new ListenableEditingState(
        new TextInputChannel.TextEditState("hello", 1, 4, 1, 4), new View(ctx));
  }

testExtractBatchTextEditingDeltas()

void io.flutter.plugin.editing.ListenableEditingStateTest.testExtractBatchTextEditingDeltas ( )

inline

Definition at line 245 of file ListenableEditingStateTest.java.

                                                  {
    final ListenableEditingState editingState = new ListenableEditingState(null, new View(ctx));
 
    // Creating some deltas.
    editingState.replace(0, editingState.length(), "test");
    editingState.delete(0, 1);
    editingState.insert(0, "This is a t");
 
    ArrayList<TextEditingDelta> batchDeltas = editingState.extractBatchTextEditingDeltas();
    assertEquals(3, batchDeltas.size());
  }

testSetComposingRegion()

void io.flutter.plugin.editing.ListenableEditingStateTest.testSetComposingRegion ( )

inline

Definition at line 206 of file ListenableEditingStateTest.java.

                                       {
    final ListenableEditingState editingState = new ListenableEditingState(null, new View(ctx));
    editingState.replace(0, editingState.length(), "text");
 
    // (-1, -1) clears the composing region.
    editingState.setComposingRange(-1, -1);
    assertEquals(-1, editingState.getComposingStart());
    assertEquals(-1, editingState.getComposingEnd());
 
    editingState.setComposingRange(-1, 5);
    assertEquals(-1, editingState.getComposingStart());
    assertEquals(-1, editingState.getComposingEnd());
 
    editingState.setComposingRange(2, 3);
    assertEquals(2, editingState.getComposingStart());
    assertEquals(3, editingState.getComposingEnd());
 
    // Empty range is invalid. Clears composing region.
    editingState.setComposingRange(1, 1);
    assertEquals(-1, editingState.getComposingStart());
    assertEquals(-1, editingState.getComposingEnd());
 
    // Covers everything.
    editingState.setComposingRange(0, editingState.length());
    assertEquals(0, editingState.getComposingStart());
    assertEquals(editingState.length(), editingState.getComposingEnd());
  }

Member Data Documentation

mockKeyboardManager

KeyboardManager io.flutter.plugin.editing.ListenableEditingStateTest.mockKeyboardManager

package

Definition at line 30 of file ListenableEditingStateTest.java.

---

The documentation for this class was generated from the following file:

• shell/platform/android/test/io/flutter/plugin/editing/ListenableEditingStateTest.java