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
17package android.text.method.cts;
18
19import com.android.cts.stub.R;
20
21
22import android.app.Activity;
23import android.app.Instrumentation;
24import android.test.ActivityInstrumentationTestCase2;
25import android.text.InputType;
26import android.text.Spannable;
27import android.text.SpannableString;
28import android.text.Spanned;
29import android.text.method.DigitsKeyListener;
30import android.view.KeyEvent;
31import android.widget.TextView;
32
33/**
34 * Test {@link DigitsKeyListener}.
35 */
36public class DigitsKeyListenerTest extends
37        ActivityInstrumentationTestCase2<KeyListenerStubActivity> {
38    private Activity mActivity;
39    private Instrumentation mInstrumentation;
40    private TextView mTextView;
41
42    public DigitsKeyListenerTest(){
43        super("com.android.cts.stub", KeyListenerStubActivity.class);
44    }
45
46    @Override
47    protected void setUp() throws Exception {
48        super.setUp();
49
50        mActivity = getActivity();
51        mInstrumentation = getInstrumentation();
52        mTextView = (TextView) mActivity.findViewById(R.id.keylistener_textview);
53    }
54
55    public void testConstructor() {
56        new DigitsKeyListener();
57
58        new DigitsKeyListener(true, true);
59    }
60
61    /**
62     * Check point:
63     * Current accepted characters are '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'.
64     * 1. filter "123456", return null.
65     * 2. filter "a1b2c3d", return "123"
66     * 3. filter "-a1.b2c3d", return "123"
67     * 4. filter Spanned("-a1.b2c3d"), return Spanned("123") and copy spans.
68     * 5. filter "", return null
69     */
70    public void testFilter1() {
71        String source = "123456";
72        String destString = "dest string";
73
74        DigitsKeyListener digitsKeyListener = DigitsKeyListener.getInstance();
75        SpannableString dest = new SpannableString(destString);
76        assertNull(digitsKeyListener.filter(source, 0, source.length(),
77                dest, 0, dest.length()));
78        assertEquals(destString, dest.toString());
79
80        source = "a1b2c3d";
81        assertEquals("123", (digitsKeyListener.filter(source, 0, source.length(),
82                dest, 0, dest.length())).toString());
83        assertEquals(destString, dest.toString());
84
85        source = "-a1.b2c3d";
86        assertEquals("123", (digitsKeyListener.filter(source, 0, source.length(),
87                dest, 0, dest.length())).toString());
88        assertEquals(destString, dest.toString());
89
90        Object what = new Object();
91        Spannable spannableSource = new SpannableString(source);
92        spannableSource.setSpan(what, 0, spannableSource.length(), Spanned.SPAN_POINT_POINT);
93        Spanned filtered = (Spanned) digitsKeyListener.filter(spannableSource,
94                0, spannableSource.length(), dest, 0, dest.length());
95        assertEquals("123", filtered.toString());
96        assertEquals(Spanned.SPAN_POINT_POINT, filtered.getSpanFlags(what));
97        assertEquals(0, filtered.getSpanStart(what));
98        assertEquals("123".length(), filtered.getSpanEnd(what));
99
100        assertNull(digitsKeyListener.filter("", 0, 0, dest, 0, dest.length()));
101        assertEquals(destString, dest.toString());
102    }
103
104    /**
105     * Check point:
106     * Current accepted characters are '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-'.
107     * 1. filter "-123456", return null
108     * 2. filter "-a1.b2c3d", return "-123"
109     * 3. filter "-a1-b2c3d", return "-123"
110     * 4. filter "5-a1-b2c3d", return "5123"
111     * 5. filter Spanned("5-a1-b2c3d"), return Spanned("5123") and copy spans.
112     * 6. filter "", return null
113     * 7. filter "-123456" but dest has '-' after dend, return ""
114     * 8. filter "-123456" but dest has '-' before dstart, return "123456"
115     */
116    public void testFilter2() {
117        String source = "-123456";
118        String destString = "dest string without sign and decimal";
119
120        DigitsKeyListener digitsKeyListener = DigitsKeyListener.getInstance(true, false);
121        SpannableString dest = new SpannableString(destString);
122        assertNull(digitsKeyListener.filter(source, 0, source.length(),
123                dest, 0, dest.length()));
124        assertEquals(destString, dest.toString());
125
126        source = "-a1.b2c3d";
127        assertEquals("-123", (digitsKeyListener.filter(source, 0, source.length(),
128                dest, 0, dest.length())).toString());
129        assertEquals(destString, dest.toString());
130
131        source = "-a1-b2c3d";
132        assertEquals("-123", (digitsKeyListener.filter(source, 0, source.length(),
133                dest, 0, dest.length())).toString());
134        assertEquals(destString, dest.toString());
135
136        source = "5-a1-b2c3d";
137        assertEquals("5123", (digitsKeyListener.filter(source, 0, source.length(),
138                dest, 0, dest.length())).toString());
139        assertEquals(destString, dest.toString());
140
141        Object what = new Object();
142        Spannable spannableSource = new SpannableString(source);
143        spannableSource.setSpan(what, 0, spannableSource.length(), Spanned.SPAN_POINT_POINT);
144        Spanned filtered = (Spanned) digitsKeyListener.filter(spannableSource,
145                0, spannableSource.length(), dest, 0, dest.length());
146        assertEquals("5123", filtered.toString());
147        assertEquals(Spanned.SPAN_POINT_POINT, filtered.getSpanFlags(what));
148        assertEquals(0, filtered.getSpanStart(what));
149        assertEquals("5123".length(), filtered.getSpanEnd(what));
150
151        assertNull(digitsKeyListener.filter("", 0, 0, dest, 0, dest.length()));
152        assertEquals(destString, dest.toString());
153
154        source = "-123456";
155        String endSign = "789-";
156        dest = new SpannableString(endSign);
157        assertEquals("", (digitsKeyListener.filter(source, 0, source.length(),
158                dest, 0, dest.length() - 1)).toString());
159        assertEquals(endSign, dest.toString());
160
161        String startSign = "-789";
162        dest = new SpannableString(startSign);
163        assertEquals("123456", (digitsKeyListener.filter(source, 0, source.length(),
164                dest, 1, dest.length())).toString());
165        assertEquals(startSign, dest.toString());
166    }
167
168    /**
169     * Check point:
170     * Current accepted characters are '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.'.
171     * 1. filter "123.456", return null
172     * 2. filter "-a1.b2c3d", return "1.23"
173     * 3. filter "a1.b2c3d.", return "123."
174     * 4. filter "5.a1.b2c3d", return "51.23"
175     * 5. filter Spanned("5.a1.b2c3d"), return Spanned("51.23") and copy spans.
176     * 6. filter "", return null
177     * 7. filter "123.456" but dest has '.' after dend, return "123456"
178     * 8. filter "123.456" but dest has '.' before dstart, return "123456"
179     */
180    public void testFilter3() {
181        String source = "123.456";
182        String destString = "dest string without sign and decimal";
183
184        DigitsKeyListener digitsKeyListener = DigitsKeyListener.getInstance(false, true);
185        SpannableString dest = new SpannableString(destString);
186        assertNull(digitsKeyListener.filter(source, 0, source.length(),
187                dest, 0, dest.length()));
188        assertEquals(destString, dest.toString());
189
190        source = "-a1.b2c3d";
191        assertEquals("1.23", (digitsKeyListener.filter(source, 0, source.length(),
192                dest, 0, dest.length())).toString());
193        assertEquals(destString, dest.toString());
194
195        source = "a1.b2c3d.";
196        assertEquals("123.", (digitsKeyListener.filter(source, 0, source.length(),
197                dest, 0, dest.length())).toString());
198        assertEquals(destString, dest.toString());
199
200        source = "5.a1.b2c3d";
201        assertEquals("51.23", (digitsKeyListener.filter(source, 0, source.length(),
202                dest, 0, dest.length())).toString());
203        assertEquals(destString, dest.toString());
204
205        Object what = new Object();
206        Spannable spannableSource = new SpannableString(source);
207        spannableSource.setSpan(what, 0, spannableSource.length(), Spanned.SPAN_POINT_POINT);
208        Spanned filtered = (Spanned) digitsKeyListener.filter(spannableSource,
209                0, spannableSource.length(), dest, 0, dest.length());
210        assertEquals("51.23", filtered.toString());
211        assertEquals(Spanned.SPAN_POINT_POINT, filtered.getSpanFlags(what));
212        assertEquals(0, filtered.getSpanStart(what));
213        assertEquals("51.23".length(), filtered.getSpanEnd(what));
214
215        assertNull(digitsKeyListener.filter("", 0, 0, dest, 0, dest.length()));
216        assertEquals(destString, dest.toString());
217
218        source = "123.456";
219        String endDecimal = "789.";
220        dest = new SpannableString(endDecimal);
221        assertEquals("123456", (digitsKeyListener.filter(source, 0, source.length(),
222                dest, 0, dest.length() - 1)).toString());
223        assertEquals(endDecimal, dest.toString());
224
225        String startDecimal = ".789";
226        dest = new SpannableString(startDecimal);
227        assertEquals("123456", (digitsKeyListener.filter(source, 0, source.length(),
228                dest, 1, dest.length())).toString());
229        assertEquals(startDecimal, dest.toString());
230    }
231
232    /**
233     * Check point:
234     * Current accepted characters are '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', '-'.
235     * 1. filter "-123.456", return null
236     * 2. filter "-a1.b2c3d", return "-1.23"
237     * 3. filter "a1.b-2c3d.", return "123."
238     * 4. filter "-5.a1.b2c3d", return "-51.23"
239     * 5. filter Spanned("-5.a1.b2c3d"), return Spanned("-51.23") and copy spans.
240     * 6. filter "", return null
241     * 7. filter "-123.456" but dest has '.' after dend, return "-123456"
242     * 8. filter "-123.456" but dest has '.' before dstart, return "123456"
243     * 9. filter "-123.456" but dest has '-' after dend, return ""
244     * 10. filter "-123.456" but dest has '-' before dstart, return "123.456"
245     */
246    public void testFilter4() {
247        String source = "-123.456";
248        String destString = "dest string without sign and decimal";
249
250        DigitsKeyListener digitsKeyListener = DigitsKeyListener.getInstance(true, true);
251        SpannableString dest = new SpannableString(destString);
252        assertNull(digitsKeyListener.filter(source, 0, source.length(),
253                dest, 0, dest.length()));
254        assertEquals(destString, dest.toString());
255
256        source = "-a1.b2c3d";
257        assertEquals("-1.23", (digitsKeyListener.filter(source, 0, source.length(),
258                dest, 0, dest.length())).toString());
259        assertEquals(destString, dest.toString());
260
261        source = "a1.b-2c3d.";
262        assertEquals("123.", (digitsKeyListener.filter(source, 0, source.length(),
263                dest, 0, dest.length())).toString());
264        assertEquals(destString, dest.toString());
265
266        source = "-5.a1.b2c3d";
267        assertEquals("-51.23", (digitsKeyListener.filter(source, 0, source.length(),
268                dest, 0, dest.length())).toString());
269        assertEquals(destString, dest.toString());
270
271        Object what = new Object();
272        Spannable spannableSource = new SpannableString(source);
273        spannableSource.setSpan(what, 0, spannableSource.length(), Spanned.SPAN_POINT_POINT);
274        Spanned filtered = (Spanned) digitsKeyListener.filter(spannableSource,
275                0, spannableSource.length(), dest, 0, dest.length());
276        assertEquals("-51.23", filtered.toString());
277        assertEquals(Spanned.SPAN_POINT_POINT, filtered.getSpanFlags(what));
278        assertEquals(0, filtered.getSpanStart(what));
279        assertEquals("-51.23".length(), filtered.getSpanEnd(what));
280
281        assertNull(digitsKeyListener.filter("", 0, 0, dest, 0, dest.length()));
282        assertEquals(destString, dest.toString());
283
284        source = "-123.456";
285        String endDecimal = "789.";
286        dest = new SpannableString(endDecimal);
287        assertEquals("-123456", (digitsKeyListener.filter(source, 0, source.length(),
288                dest, 0, dest.length() - 1)).toString());
289        assertEquals(endDecimal, dest.toString());
290
291        String startDecimal = ".789";
292        dest = new SpannableString(startDecimal);
293        assertEquals("123456", (digitsKeyListener.filter(source, 0, source.length(),
294                dest, 1, dest.length())).toString());
295        assertEquals(startDecimal, dest.toString());
296
297        String endSign = "789-";
298        dest = new SpannableString(endSign);
299        assertEquals("", (digitsKeyListener.filter(source, 0, source.length(),
300                dest, 0, dest.length() - 1)).toString());
301        assertEquals(endSign, dest.toString());
302
303        String startSign = "-789";
304        dest = new SpannableString(startSign);
305        assertEquals("123.456", (digitsKeyListener.filter(source, 0, source.length(),
306                dest, 1, dest.length())).toString());
307        assertEquals(startSign, dest.toString());
308    }
309
310    /**
311     * Scenario description:
312     * Current accepted characters are '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'.
313     *  1. Press '-' key and this key could not be accepted.
314     *  2. Press '1' key and check if the content of TextView becomes "1"
315     *  3. Press '.' key and this key could not be accepted.
316     *  4. Press '2' key and check if the content of TextView becomes "12"
317     */
318    public void testDigitsKeyListener1() {
319        final DigitsKeyListener digitsKeyListener = DigitsKeyListener.getInstance();
320
321        mActivity.runOnUiThread(new Runnable() {
322            public void run() {
323                mTextView.setKeyListener(digitsKeyListener);
324                mTextView.requestFocus();
325            }
326        });
327        mInstrumentation.waitForIdleSync();
328        assertEquals("", mTextView.getText().toString());
329
330        // press '-' key.
331        sendKeys(KeyEvent.KEYCODE_MINUS);
332        assertEquals("", mTextView.getText().toString());
333
334        // press '1' key.
335        sendKeys(KeyEvent.KEYCODE_1);
336        assertEquals("1", mTextView.getText().toString());
337
338        // press '.' key.
339        sendKeys(KeyEvent.KEYCODE_PERIOD);
340        assertEquals("1", mTextView.getText().toString());
341
342        // press '2' key.
343        sendKeys(KeyEvent.KEYCODE_2);
344        assertEquals("12", mTextView.getText().toString());
345    }
346
347    /**
348     * Scenario description:
349     * Current accepted characters are '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-'.
350     *  1. Press '-' key and check if the content of TextView becomes "-"
351     *  2. Press '1' key and check if the content of TextView becomes "-1"
352     *  3. Press '.' key and this key could not be accepted.
353     *  4. Press '2' key and check if the content of TextView becomes "-12"
354     *  5. Press '-' key and this key could not be accepted,
355     *     because text view accepts minus sign iff it at the beginning.
356     */
357    public void testDigitsKeyListener2() {
358        final DigitsKeyListener digitsKeyListener = DigitsKeyListener.getInstance(true, false);
359
360        mActivity.runOnUiThread(new Runnable() {
361            public void run() {
362                mTextView.setKeyListener(digitsKeyListener);
363                mTextView.requestFocus();
364            }
365        });
366        mInstrumentation.waitForIdleSync();
367        assertEquals("", mTextView.getText().toString());
368
369        // press '-' key.
370        sendKeys(KeyEvent.KEYCODE_MINUS);
371        assertEquals("-", mTextView.getText().toString());
372
373        // press '1' key.
374        sendKeys(KeyEvent.KEYCODE_1);
375        assertEquals("-1", mTextView.getText().toString());
376
377        // press '.' key.
378        sendKeys(KeyEvent.KEYCODE_PERIOD);
379        assertEquals("-1", mTextView.getText().toString());
380
381        // press '2' key.
382        sendKeys(KeyEvent.KEYCODE_2);
383        assertEquals("-12", mTextView.getText().toString());
384
385        // press '-' key.
386        sendKeys(KeyEvent.KEYCODE_MINUS);
387        assertEquals("-12", mTextView.getText().toString());
388    }
389
390    /**
391     * Scenario description:
392     * Current accepted characters are '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.'.
393     *  1. Press '-' key and check if the content of TextView becomes ""
394     *  2. Press '1' key and check if the content of TextView becomes "1"
395     *  3. Press '.' key and check if the content of TextView becomes "1."
396     *  4. Press '2' key and check if the content of TextView becomes "1.2"
397     *  5. Press '.' key and this key could not be accepted,
398     *     because text view accepts only one decimal point per field.
399     */
400    public void testDigitsKeyListener3() {
401//        final DigitsKeyListener digitsKeyListener = DigitsKeyListener.getInstance(false, true);
402//
403//        mActivity.runOnUiThread(new Runnable() {
404//            public void run() {
405//                mTextView.setKeyListener(digitsKeyListener);
406//                mTextView.requestFocus();
407//            }
408//        });
409//        mInstrumentation.waitForIdleSync();
410//        assertEquals("", mTextView.getText().toString());
411//
412//        // press '-' key.
413//        sendKeys(KeyEvent.KEYCODE_MINUS);
414//        assertEquals("", mTextView.getText().toString());
415//
416//        // press '1' key.
417//        sendKeys(KeyEvent.KEYCODE_1);
418//        assertEquals("1", mTextView.getText().toString());
419//
420//        // press '.' key.
421//        sendKeys(KeyEvent.KEYCODE_PERIOD);
422//        assertEquals("1.", mTextView.getText().toString());
423//
424//        // press '2' key.
425//        sendKeys(KeyEvent.KEYCODE_2);
426//        assertEquals("1.2", mTextView.getText().toString());
427//
428//        // press '.' key.
429//        sendKeys(KeyEvent.KEYCODE_PERIOD);
430//        assertEquals("1.2", mTextView.getText().toString());
431    }
432
433    /**
434     * Scenario description:
435     * Current accepted characters are '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '.'.
436     *  1. Press '-' key and check if the content of TextView becomes "-"
437     *  2. Press '1' key and check if the content of TextView becomes "-1"
438     *  3. Press '.' key and this key could not be accepted.
439     *  4. Press '2' key and check if the content of TextView becomes "-12"
440     *  5. Press '-' key and this key could not be accepted,
441     *     because text view accepts minus sign iff it at the beginning.
442     *  6. Press '.' key and this key could not be accepted,
443     *     because text view accepts only one decimal point per field.
444     */
445    public void testDigitsKeyListener4() {
446//        final DigitsKeyListener digitsKeyListener = DigitsKeyListener.getInstance(true, true);
447//
448//        mActivity.runOnUiThread(new Runnable() {
449//            public void run() {
450//                mTextView.setKeyListener(digitsKeyListener);
451//                mTextView.requestFocus();
452//            }
453//        });
454//        mInstrumentation.waitForIdleSync();
455//        assertEquals("", mTextView.getText().toString());
456//
457//        // press '-' key.
458//        sendKeys(KeyEvent.KEYCODE_MINUS);
459//        assertEquals("-", mTextView.getText().toString());
460//
461//        // press '1' key.
462//        sendKeys(KeyEvent.KEYCODE_1);
463//        assertEquals("-1", mTextView.getText().toString());
464//
465//        // press '.' key.
466//        sendKeys(KeyEvent.KEYCODE_PERIOD);
467//        assertEquals("-1.", mTextView.getText().toString());
468//
469//        // press '2' key.
470//        sendKeys(KeyEvent.KEYCODE_2);
471//        assertEquals("-1.2", mTextView.getText().toString());
472//
473//        // press '-' key.
474//        sendKeys(KeyEvent.KEYCODE_MINUS);
475//        assertEquals("-1.2", mTextView.getText().toString());
476//
477//        // press '.' key.
478//        sendKeys(KeyEvent.KEYCODE_PERIOD);
479//        assertEquals("-1.2", mTextView.getText().toString());
480    }
481
482    /**
483     * Scenario description:
484     * Current accepted characters are '5', '6', '7', '8', '9'.
485     *  1. Press '1' key and this key could not be accepted.
486     *  2. Press '5' key and check if the content of TextView becomes "5"
487     *  3. Press '.' key and this key could not be accepted.
488     *  4. Press '-' key and this key could not be accepted.
489     *  5. remove DigitsKeyListener and Press '5' key, this key will not be accepted
490     */
491    public void testDigitsKeyListener5() {
492        final String accepted = "56789";
493        final DigitsKeyListener digitsKeyListener = DigitsKeyListener.getInstance(accepted);
494
495        mActivity.runOnUiThread(new Runnable() {
496            public void run() {
497                mTextView.setKeyListener(digitsKeyListener);
498                mTextView.requestFocus();
499            }
500        });
501        mInstrumentation.waitForIdleSync();
502        assertEquals("", mTextView.getText().toString());
503
504        // press '1' key.
505        sendKeys(KeyEvent.KEYCODE_1);
506        assertEquals("", mTextView.getText().toString());
507
508        // press '5' key.
509        sendKeys(KeyEvent.KEYCODE_5);
510        assertEquals("5", mTextView.getText().toString());
511
512        // press '.' key.
513        sendKeys(KeyEvent.KEYCODE_PERIOD);
514        assertEquals("5", mTextView.getText().toString());
515
516        // press '-' key.
517        sendKeys(KeyEvent.KEYCODE_MINUS);
518        assertEquals("5", mTextView.getText().toString());
519
520        // remove DigitsKeyListener
521        mActivity.runOnUiThread(new Runnable() {
522            public void run() {
523                mTextView.setKeyListener(null);
524                mTextView.requestFocus();
525            }
526        });
527        mInstrumentation.waitForIdleSync();
528        assertEquals("5", mTextView.getText().toString());
529
530        // press '5' key.
531        sendKeys(KeyEvent.KEYCODE_5);
532        assertEquals("5", mTextView.getText().toString());
533    }
534
535    public void testGetInstance1() {
536        DigitsKeyListener listener1 = DigitsKeyListener.getInstance();
537        DigitsKeyListener listener2 = DigitsKeyListener.getInstance();
538
539        assertNotNull(listener1);
540        assertNotNull(listener2);
541        assertSame(listener1, listener2);
542    }
543
544    public void testGetInstance2() {
545        DigitsKeyListener listener1 = DigitsKeyListener.getInstance(true, true);
546        DigitsKeyListener listener2 = DigitsKeyListener.getInstance(true, true);
547
548        assertNotNull(listener1);
549        assertNotNull(listener2);
550        assertSame(listener1, listener2);
551
552        listener1 = DigitsKeyListener.getInstance(true, false);
553        listener2 = DigitsKeyListener.getInstance(true, false);
554
555        assertNotNull(listener1);
556        assertNotNull(listener2);
557        assertSame(listener1, listener2);
558    }
559
560    public void testGetInstance3() {
561        DigitsKeyListener digitsKeyListener = DigitsKeyListener.getInstance("abcdefg");
562        assertNotNull(digitsKeyListener);
563
564        digitsKeyListener = DigitsKeyListener.getInstance("Android Test");
565        assertNotNull(digitsKeyListener);
566    }
567
568    public void testGetAcceptedChars() {
569        MyDigitsKeyListener digitsKeyListener = new MyDigitsKeyListener();
570
571        final char[][] expected = new char[][] {
572            new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' },
573            new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-' },
574            new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.' },
575            new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '.' },
576        };
577
578        TextMethodUtils.assertEquals(expected[0],
579                digitsKeyListener.getAcceptedChars());
580
581        digitsKeyListener = new MyDigitsKeyListener(true, false);
582        TextMethodUtils.assertEquals(expected[1],
583                digitsKeyListener.getAcceptedChars());
584
585        digitsKeyListener = new MyDigitsKeyListener(false, true);
586        TextMethodUtils.assertEquals(expected[2],
587                digitsKeyListener.getAcceptedChars());
588
589        digitsKeyListener = new MyDigitsKeyListener(true, true);
590        TextMethodUtils.assertEquals(expected[3],
591                digitsKeyListener.getAcceptedChars());
592    }
593
594    public void testGetInputType() {
595        DigitsKeyListener digitsKeyListener = DigitsKeyListener.getInstance(false, false);
596        int expected = InputType.TYPE_CLASS_NUMBER;
597        assertEquals(expected, digitsKeyListener.getInputType());
598
599        digitsKeyListener = DigitsKeyListener.getInstance(true, false);
600        expected = InputType.TYPE_CLASS_NUMBER
601                | InputType.TYPE_NUMBER_FLAG_SIGNED;
602        assertEquals(expected, digitsKeyListener.getInputType());
603
604        digitsKeyListener = DigitsKeyListener.getInstance(false, true);
605        expected = InputType.TYPE_CLASS_NUMBER
606                | InputType.TYPE_NUMBER_FLAG_DECIMAL;
607        assertEquals(expected, digitsKeyListener.getInputType());
608
609        digitsKeyListener = DigitsKeyListener.getInstance(true, true);
610        expected = InputType.TYPE_CLASS_NUMBER
611                | InputType.TYPE_NUMBER_FLAG_SIGNED
612                | InputType.TYPE_NUMBER_FLAG_DECIMAL;
613        assertEquals(expected, digitsKeyListener.getInputType());
614    }
615
616    private class MyDigitsKeyListener extends DigitsKeyListener {
617        public MyDigitsKeyListener() {
618            super();
619        }
620
621        public MyDigitsKeyListener(boolean sign, boolean decimal) {
622            super(sign, decimal);
623        }
624
625        @Override
626        protected char[] getAcceptedChars() {
627            return super.getAcceptedChars();
628        }
629    }
630}
631