Home | History | Annotate | Download | only in cts 
      1 /*
      2  * Copyright (C) 2008 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package android.text.method.cts;
     18 
     19 import static org.junit.Assert.assertEquals;
     20 import static org.junit.Assert.assertNotNull;
     21 import static org.junit.Assert.assertNotSame;
     22 import static org.junit.Assert.assertSame;
     23 
     24 import android.support.test.filters.MediumTest;
     25 import android.support.test.runner.AndroidJUnit4;
     26 import android.text.InputType;
     27 import android.text.Selection;
     28 import android.text.Spannable;
     29 import android.text.SpannableStringBuilder;
     30 import android.text.method.QwertyKeyListener;
     31 import android.text.method.TextKeyListener.Capitalize;
     32 import android.view.KeyEvent;
     33 import android.widget.TextView.BufferType;
     34 
     35 import org.junit.After;
     36 import org.junit.Before;
     37 import org.junit.Test;
     38 import org.junit.runner.RunWith;
     39 
     40 import java.io.IOException;
     41 
     42 @MediumTest
     43 @RunWith(AndroidJUnit4.class)
     44 public class QwertyKeyListenerTest extends KeyListenerTestCase {
     45 
     46     @Before
     47     public void setup() throws IOException {
     48         super.setup();
     49         enableAutoCapSettings();
     50     }
     51 
     52     @After
     53     public void tearDown() throws IOException {
     54         resetAutoCapSettings();
     55     }
     56 
     57     @Test
     58     public void testConstructor() {
     59         new QwertyKeyListener(Capitalize.NONE, false);
     60 
     61         new QwertyKeyListener(Capitalize.WORDS, true);
     62 
     63         new QwertyKeyListener(null, true);
     64     }
     65 
     66     @Test
     67     public void testOnKeyDown_capitalizeNone() {
     68         final QwertyKeyListener keyListener = QwertyKeyListener.getInstance(false, Capitalize.NONE);
     69 
     70         prepareEmptyTextView();
     71 
     72         callOnKeyDown(keyListener, KeyEvent.KEYCODE_H);
     73         assertEquals("h", mTextView.getText().toString());
     74 
     75         callOnKeyDown(keyListener, KeyEvent.KEYCODE_E);
     76         assertEquals("he", mTextView.getText().toString());
     77 
     78         callOnKeyDown(keyListener, KeyEvent.KEYCODE_L);
     79         assertEquals("hel", mTextView.getText().toString());
     80 
     81         callOnKeyDown(keyListener, KeyEvent.KEYCODE_L);
     82         assertEquals("hell", mTextView.getText().toString());
     83 
     84         callOnKeyDown(keyListener, KeyEvent.KEYCODE_O);
     85         assertEquals("hello", mTextView.getText().toString());
     86     }
     87 
     88     @Test
     89     public void testOnKeyDown_capitalizeCharacters() {
     90         final QwertyKeyListener keyListener = QwertyKeyListener.getInstance(false,
     91                 Capitalize.CHARACTERS);
     92 
     93         prepareEmptyTextView();
     94 
     95         callOnKeyDown(keyListener, KeyEvent.KEYCODE_H);
     96         assertEquals("H", mTextView.getText().toString());
     97 
     98         callOnKeyDown(keyListener, KeyEvent.KEYCODE_E);
     99         assertEquals("HE", mTextView.getText().toString());
    100 
    101         callOnKeyDown(keyListener, KeyEvent.KEYCODE_L);
    102         assertEquals("HEL", mTextView.getText().toString());
    103 
    104         callOnKeyDown(keyListener, KeyEvent.KEYCODE_L);
    105         assertEquals("HELL", mTextView.getText().toString());
    106 
    107         callOnKeyDown(keyListener, KeyEvent.KEYCODE_O);
    108         assertEquals("HELLO", mTextView.getText().toString());
    109     }
    110 
    111     @Test
    112     public void testOnKeyDown_capitalizeSentences() {
    113         final QwertyKeyListener keyListener = QwertyKeyListener.getInstance(false,
    114                 Capitalize.SENTENCES);
    115 
    116         prepareEmptyTextView();
    117 
    118         callOnKeyDown(keyListener, KeyEvent.KEYCODE_H);
    119         assertEquals("H", mTextView.getText().toString());
    120 
    121         callOnKeyDown(keyListener, KeyEvent.KEYCODE_I);
    122         assertEquals("Hi", mTextView.getText().toString());
    123 
    124         callOnKeyDown(keyListener, KeyEvent.KEYCODE_PERIOD);
    125         assertEquals("Hi.", mTextView.getText().toString());
    126 
    127         callOnKeyDown(keyListener, KeyEvent.KEYCODE_SPACE);
    128         assertEquals("Hi. ", mTextView.getText().toString());
    129 
    130         callOnKeyDown(keyListener, KeyEvent.KEYCODE_B);
    131         assertEquals("Hi. B", mTextView.getText().toString());
    132 
    133         callOnKeyDown(keyListener, KeyEvent.KEYCODE_Y);
    134         assertEquals("Hi. By", mTextView.getText().toString());
    135 
    136         callOnKeyDown(keyListener, KeyEvent.KEYCODE_E);
    137         assertEquals("Hi. Bye", mTextView.getText().toString());
    138     }
    139 
    140     @Test
    141     public void testOnKeyDown_capitalizeWords() {
    142         final QwertyKeyListener keyListener = QwertyKeyListener.getInstance(false,
    143                 Capitalize.WORDS);
    144 
    145         prepareEmptyTextView();
    146 
    147         callOnKeyDown(keyListener, KeyEvent.KEYCODE_H);
    148         assertEquals("H", mTextView.getText().toString());
    149 
    150         callOnKeyDown(keyListener, KeyEvent.KEYCODE_I);
    151         assertEquals("Hi", mTextView.getText().toString());
    152 
    153         callOnKeyDown(keyListener, KeyEvent.KEYCODE_SPACE);
    154         assertEquals("Hi ", mTextView.getText().toString());
    155 
    156         callOnKeyDown(keyListener, KeyEvent.KEYCODE_B);
    157         assertEquals("Hi B", mTextView.getText().toString());
    158 
    159         callOnKeyDown(keyListener, KeyEvent.KEYCODE_Y);
    160         assertEquals("Hi By", mTextView.getText().toString());
    161 
    162         callOnKeyDown(keyListener, KeyEvent.KEYCODE_E);
    163         assertEquals("Hi Bye", mTextView.getText().toString());
    164     }
    165 
    166     private void prepareEmptyTextView() {
    167         mInstrumentation.runOnMainSync(() -> {
    168             mTextView.setText("", BufferType.EDITABLE);
    169             Selection.setSelection(mTextView.getEditableText(), 0, 0);
    170         });
    171         mInstrumentation.waitForIdleSync();
    172         assertEquals("", mTextView.getText().toString());
    173     }
    174 
    175     private void callOnKeyDown(final QwertyKeyListener keyListener, final int keyCode) {
    176         mInstrumentation.runOnMainSync(() -> keyListener.onKeyDown(mTextView,
    177                 mTextView.getEditableText(), keyCode,
    178                 new KeyEvent(KeyEvent.ACTION_DOWN, keyCode)));
    179         mInstrumentation.waitForIdleSync();
    180     }
    181 
    182     @Test
    183     public void testGetInstance() {
    184         final QwertyKeyListener listener1 = QwertyKeyListener.getInstance(true, Capitalize.WORDS);
    185         final QwertyKeyListener listener2 = QwertyKeyListener.getInstance(true, Capitalize.WORDS);
    186         final QwertyKeyListener listener3 = QwertyKeyListener.getInstance(false, Capitalize.WORDS);
    187         final QwertyKeyListener listener4 = QwertyKeyListener.getInstance(true,
    188                 Capitalize.SENTENCES);
    189 
    190         assertNotNull(listener1);
    191         assertNotNull(listener2);
    192         assertSame(listener1, listener2);
    193 
    194         assertNotSame(listener1, listener3);
    195         assertNotSame(listener1, listener4);
    196         assertNotSame(listener4, listener3);
    197     }
    198 
    199     @Test
    200     public void testGetInstanceForFullKeyboard() {
    201         final QwertyKeyListener listener = QwertyKeyListener.getInstanceForFullKeyboard();
    202 
    203         assertNotNull(listener);
    204         // auto correct and cap flags should not be set
    205         assertEquals(InputType.TYPE_CLASS_TEXT, listener.getInputType());
    206     }
    207 
    208     @Test
    209     public void testMarkAsReplaced() {
    210         final SpannableStringBuilder content = new SpannableStringBuilder("123456");
    211 
    212         Object[] repl = content.getSpans(0, content.length(), Object.class);
    213         assertEquals(0, repl.length);
    214 
    215         QwertyKeyListener.markAsReplaced(content, 0, content.length(), "abcd");
    216         repl = content.getSpans(0, content.length(), Object.class);
    217         assertEquals(1, repl.length);
    218         assertEquals(0, content.getSpanStart(repl[0]));
    219         assertEquals(content.length(), content.getSpanEnd(repl[0]));
    220         assertEquals(Spannable.SPAN_EXCLUSIVE_EXCLUSIVE, content.getSpanFlags(repl[0]));
    221 
    222         QwertyKeyListener.markAsReplaced(content, 1, 2, "abcd");
    223         repl = content.getSpans(0, content.length(), Object.class);
    224         assertEquals(1, repl.length);
    225         assertEquals(1, content.getSpanStart(repl[0]));
    226         assertEquals(2, content.getSpanEnd(repl[0]));
    227         assertEquals(Spannable.SPAN_EXCLUSIVE_EXCLUSIVE, content.getSpanFlags(repl[0]));
    228     }
    229 
    230     @Test(expected=NullPointerException.class)
    231     public void testMarkAsReplacedNullContent() {
    232         QwertyKeyListener.markAsReplaced(null, 1, 2, "abcd");
    233     }
    234 
    235     @Test(expected=NullPointerException.class)
    236     public void testMarkAsReplacedNullOriginal() {
    237         QwertyKeyListener.markAsReplaced(new SpannableStringBuilder("123456"), 1, 2, null);
    238     }
    239 
    240     @Test
    241     public void testGetInputType() {
    242         QwertyKeyListener listener = QwertyKeyListener.getInstance(false, Capitalize.NONE);
    243         assertEquals(InputType.TYPE_CLASS_TEXT, listener.getInputType());
    244 
    245         listener = QwertyKeyListener.getInstance(false, Capitalize.CHARACTERS);
    246         final int expected = InputType.TYPE_CLASS_TEXT
    247                 | InputType.TYPE_TEXT_FLAG_CAP_CHARACTERS;
    248         assertEquals(expected, listener.getInputType());
    249     }
    250 }
    251