WordIteratorTest.java revision 9dad5811d7232c85c07761dddd9ebd035524f955 
1/*
2 * Copyright (C) 2015 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;
18
19import android.test.AndroidTestCase;
20import android.test.suitebuilder.annotation.SmallTest;
21
22import java.text.BreakIterator;
23import java.util.Locale;
24
25// TODO(Bug: 24062099): Add more tests for non-ascii text.
26public class WordIteratorTest  extends AndroidTestCase {
27
28    @SmallTest
29    public void testSetCharSequence() {
30        final String text = "text";
31        WordIterator wordIterator = new WordIterator(Locale.ENGLISH);
32
33        try {
34            wordIterator.setCharSequence(text, 100, 100);
35            fail("setCharSequence with invalid start and end values should throw "
36                    + "IndexOutOfBoundsException.");
37        } catch (IndexOutOfBoundsException e) {
38        }
39        try {
40            wordIterator.setCharSequence(text, -100, -100);
41            fail("setCharSequence with invalid start and end values should throw "
42                    + "IndexOutOfBoundsException.");
43        } catch (IndexOutOfBoundsException e) {
44        }
45
46        wordIterator.setCharSequence(text, 0, text.length());
47        wordIterator.setCharSequence(text, 0, 0);
48        wordIterator.setCharSequence(text, text.length(), text.length());
49    }
50
51    @SmallTest
52    public void testPreceding() {
53        final String text = "abc def-ghi. jkl";
54        WordIterator wordIterator = new WordIterator(Locale.ENGLISH);
55        wordIterator.setCharSequence(text, 0, text.length());
56
57        try {
58            wordIterator.preceding(-1);
59            fail("preceding with invalid offset should throw IllegalArgumentException.");
60        } catch (IllegalArgumentException e) {
61        }
62        try {
63            wordIterator.preceding(text.length() + 1);
64            fail("preceding with invalid offset should throw IllegalArgumentException.");
65        } catch (IllegalArgumentException e) {
66        }
67
68        assertEquals(BreakIterator.DONE, wordIterator.preceding(text.indexOf('a')));
69        assertEquals(text.indexOf('a'), wordIterator.preceding(text.indexOf('c')));
70        assertEquals(text.indexOf('a'), wordIterator.preceding(text.indexOf('d')));
71        assertEquals(text.indexOf('d'), wordIterator.preceding(text.indexOf('e')));
72        assertEquals(text.indexOf('d'), wordIterator.preceding(text.indexOf('g')));
73        assertEquals(text.indexOf('g'), wordIterator.preceding(text.indexOf('h')));
74        assertEquals(text.indexOf('g'), wordIterator.preceding(text.indexOf('j')));
75        assertEquals(text.indexOf('j'), wordIterator.preceding(text.indexOf('l')));
76    }
77
78    @SmallTest
79    public void testFollowing() {
80        final String text = "abc def-ghi. jkl";
81        WordIterator wordIterator = new WordIterator(Locale.ENGLISH);
82        wordIterator.setCharSequence(text, 0, text.length());
83
84        try {
85            wordIterator.following(-1);
86            fail("following with invalid offset should throw IllegalArgumentException.");
87        } catch (IllegalArgumentException e) {
88        }
89        try {
90            wordIterator.following(text.length() + 1);
91            fail("following with invalid offset should throw IllegalArgumentException.");
92        } catch (IllegalArgumentException e) {
93        }
94
95        assertEquals(text.indexOf('c') + 1, wordIterator.following(text.indexOf('a')));
96        assertEquals(text.indexOf('c') + 1, wordIterator.following(text.indexOf('c')));
97        assertEquals(text.indexOf('f') + 1, wordIterator.following(text.indexOf('c') + 1));
98        assertEquals(text.indexOf('f') + 1, wordIterator.following(text.indexOf('d')));
99        assertEquals(text.indexOf('i') + 1, wordIterator.following(text.indexOf('-')));
100        assertEquals(text.indexOf('i') + 1, wordIterator.following(text.indexOf('g')));
101        assertEquals(text.length(), wordIterator.following(text.indexOf('j')));
102        assertEquals(BreakIterator.DONE, wordIterator.following(text.length()));
103    }
104
105    @SmallTest
106    public void testIsBoundary() {
107        final String text = "abc def-ghi. jkl";
108        WordIterator wordIterator = new WordIterator(Locale.ENGLISH);
109        wordIterator.setCharSequence(text, 0, text.length());
110
111        try {
112            wordIterator.isBoundary(-1);
113            fail("isBoundary with invalid offset should throw IllegalArgumentException.");
114        } catch (IllegalArgumentException e) {
115        }
116        try {
117            wordIterator.isBoundary(text.length() + 1);
118            fail("isBoundary with invalid offset should throw IllegalArgumentException.");
119        } catch (IllegalArgumentException e) {
120        }
121
122        assertTrue(wordIterator.isBoundary(text.indexOf('a')));
123        assertFalse(wordIterator.isBoundary(text.indexOf('b')));
124        assertTrue(wordIterator.isBoundary(text.indexOf('c') + 1));
125        assertTrue(wordIterator.isBoundary(text.indexOf('d')));
126        assertTrue(wordIterator.isBoundary(text.indexOf('-')));
127        assertTrue(wordIterator.isBoundary(text.indexOf('g')));
128        assertTrue(wordIterator.isBoundary(text.indexOf('.')));
129        assertTrue(wordIterator.isBoundary(text.indexOf('j')));
130        assertTrue(wordIterator.isBoundary(text.length()));
131    }
132
133    @SmallTest
134    public void testNextBoundary() {
135        final String text = "abc def-ghi. jkl";
136        WordIterator wordIterator = new WordIterator(Locale.ENGLISH);
137        wordIterator.setCharSequence(text, 0, text.length());
138
139        try {
140            wordIterator.nextBoundary(-1);
141            fail("nextBoundary with invalid offset should throw IllegalArgumentException.");
142        } catch (IllegalArgumentException e) {
143        }
144        try {
145            wordIterator.nextBoundary(text.length() + 1);
146            fail("nextBoundary with invalid offset should throw IllegalArgumentException.");
147        } catch (IllegalArgumentException e) {
148        }
149
150
151        int currentOffset = 0;
152        currentOffset = wordIterator.nextBoundary(currentOffset);
153        assertEquals(text.indexOf('c') + 1, currentOffset);
154
155        currentOffset = wordIterator.nextBoundary(currentOffset);
156        assertEquals(text.indexOf('d'), currentOffset);
157
158        currentOffset = wordIterator.nextBoundary(currentOffset);
159        assertEquals(text.indexOf('f') + 1, currentOffset);
160
161        currentOffset = wordIterator.nextBoundary(currentOffset);
162        assertEquals(text.indexOf('g'), currentOffset);
163
164        currentOffset = wordIterator.nextBoundary(currentOffset);
165        assertEquals(text.indexOf('i') + 1, currentOffset);
166
167        currentOffset = wordIterator.nextBoundary(currentOffset);
168        assertEquals(text.indexOf('.') + 1, currentOffset);
169
170        currentOffset = wordIterator.nextBoundary(currentOffset);
171        assertEquals(text.indexOf('j'), currentOffset);
172
173        currentOffset = wordIterator.nextBoundary(currentOffset);
174        assertEquals(text.length(), currentOffset);
175
176        currentOffset = wordIterator.nextBoundary(currentOffset);
177        assertEquals(BreakIterator.DONE, currentOffset);
178    }
179
180    @SmallTest
181    public void testPrevBoundary() {
182        final String text = "abc def-ghi. jkl";
183        WordIterator wordIterator = new WordIterator(Locale.ENGLISH);
184        wordIterator.setCharSequence(text, 0, text.length());
185
186        try {
187            wordIterator.prevBoundary(-1);
188            fail("prevBoundary with invalid offset should throw IllegalArgumentException.");
189        } catch (IllegalArgumentException e) {
190        }
191        try {
192            wordIterator.prevBoundary(text.length() + 1);
193            fail("prevBoundary with invalid offset should throw IllegalArgumentException.");
194        } catch (IllegalArgumentException e) {
195        }
196
197        int currentOffset = text.length();
198        currentOffset = wordIterator.prevBoundary(currentOffset);
199        assertEquals(text.indexOf('j'), currentOffset);
200
201        currentOffset = wordIterator.prevBoundary(currentOffset);
202        assertEquals(text.indexOf('.') + 1, currentOffset);
203
204        currentOffset = wordIterator.prevBoundary(currentOffset);
205        assertEquals(text.indexOf('i') + 1, currentOffset);
206
207        currentOffset = wordIterator.prevBoundary(currentOffset);
208        assertEquals(text.indexOf('g'), currentOffset);
209
210        currentOffset = wordIterator.prevBoundary(currentOffset);
211        assertEquals(text.indexOf('f') + 1, currentOffset);
212
213        currentOffset = wordIterator.prevBoundary(currentOffset);
214        assertEquals(text.indexOf('d'), currentOffset);
215
216        currentOffset = wordIterator.prevBoundary(currentOffset);
217        assertEquals(text.indexOf('c') + 1, currentOffset);
218
219        currentOffset = wordIterator.prevBoundary(currentOffset);
220        assertEquals(text.indexOf('a'), currentOffset);
221
222        currentOffset = wordIterator.prevBoundary(currentOffset);
223        assertEquals(BreakIterator.DONE, currentOffset);
224    }
225
226    @SmallTest
227    public void testGetBeginning() {
228        {
229            final String text = "abc def-ghi. jkl";
230            WordIterator wordIterator = new WordIterator(Locale.ENGLISH);
231            wordIterator.setCharSequence(text, 0, text.length());
232            try {
233                wordIterator.getBeginning(-1);
234                fail("getBeginning with invalid offset should throw IllegalArgumentException.");
235            } catch (IllegalArgumentException e) {
236            }
237            try {
238                wordIterator.getBeginning(text.length() + 1);
239                fail("getBeginning with invalid offset should throw IllegalArgumentException.");
240            } catch (IllegalArgumentException e) {
241            }
242            try {
243                wordIterator.getPrevWordBeginningOnTwoWordsBoundary(-1);
244                fail("getPrevWordBeginningOnTwoWordsBoundary with invalid offset should throw "
245                        + "IllegalArgumentException.");
246            } catch (IllegalArgumentException e) {
247            }
248            try {
249                wordIterator.getPrevWordBeginningOnTwoWordsBoundary(text.length() + 1);
250                fail("getPrevWordBeginningOnTwoWordsBoundary with invalid offset should throw "
251                        + "IllegalArgumentException.");
252            } catch (IllegalArgumentException e) {
253            }
254        }
255
256        {
257            final String text = "abc def-ghi. jkl";
258            WordIterator wordIterator = new WordIterator(Locale.ENGLISH);
259            wordIterator.setCharSequence(text, 0, text.length());
260
261            assertEquals(text.indexOf('a'), wordIterator.getBeginning(text.indexOf('a')));
262            assertEquals(text.indexOf('a'), wordIterator.getBeginning(text.indexOf('c')));
263            assertEquals(text.indexOf('a'), wordIterator.getBeginning(text.indexOf('c') + 1));
264            assertEquals(text.indexOf('d'), wordIterator.getBeginning(text.indexOf('d')));
265            assertEquals(text.indexOf('d'), wordIterator.getBeginning(text.indexOf('-')));
266            assertEquals(text.indexOf('g'), wordIterator.getBeginning(text.indexOf('g')));
267            assertEquals(text.indexOf('g'), wordIterator.getBeginning(text.indexOf('.')));
268            assertEquals(BreakIterator.DONE, wordIterator.getBeginning(text.indexOf('.') + 1));
269            assertEquals(text.indexOf('j'), wordIterator.getBeginning(text.indexOf('j')));
270            assertEquals(text.indexOf('j'), wordIterator.getBeginning(text.indexOf('l') + 1));
271
272            for (int i = 0; i < text.length(); i++) {
273                assertEquals(wordIterator.getBeginning(i),
274                        wordIterator.getPrevWordBeginningOnTwoWordsBoundary(i));
275            }
276        }
277
278        {
279            // Japanese HIRAGANA letter + KATAKANA letters
280            final String text = "\u3042\u30A2\u30A3\u30A4";
281            WordIterator wordIterator = new WordIterator(Locale.JAPANESE);
282            wordIterator.setCharSequence(text, 0, text.length());
283
284            assertEquals(text.indexOf('\u3042'), wordIterator.getBeginning(text.indexOf('\u3042')));
285            assertEquals(text.indexOf('\u30A2'), wordIterator.getBeginning(text.indexOf('\u30A2')));
286            assertEquals(text.indexOf('\u30A2'), wordIterator.getBeginning(text.indexOf('\u30A4')));
287            assertEquals(text.indexOf('\u30A2'), wordIterator.getBeginning(text.length()));
288
289            assertEquals(text.indexOf('\u3042'),
290                    wordIterator.getPrevWordBeginningOnTwoWordsBoundary(text.indexOf('\u3042')));
291            assertEquals(text.indexOf('\u3042'),
292                    wordIterator.getPrevWordBeginningOnTwoWordsBoundary(text.indexOf('\u30A2')));
293            assertEquals(text.indexOf('\u30A2'),
294                    wordIterator.getPrevWordBeginningOnTwoWordsBoundary(text.indexOf('\u30A4')));
295            assertEquals(text.indexOf('\u30A2'),
296                    wordIterator.getPrevWordBeginningOnTwoWordsBoundary(text.length()));
297        }
298    }
299
300    @SmallTest
301    public void testGetEnd() {
302        {
303            final String text = "abc def-ghi. jkl";
304            WordIterator wordIterator = new WordIterator(Locale.ENGLISH);
305            wordIterator.setCharSequence(text, 0, text.length());
306            try {
307                wordIterator.getEnd(-1);
308                fail("getEnd with invalid offset should throw IllegalArgumentException.");
309            } catch (IllegalArgumentException e) {
310            }
311            try {
312                wordIterator.getEnd(text.length() + 1);
313                fail("getEnd with invalid offset should throw IllegalArgumentException.");
314            } catch (IllegalArgumentException e) {
315            }
316            try {
317                wordIterator.getNextWordEndOnTwoWordBoundary(-1);
318                fail("getNextWordEndOnTwoWordBoundary with invalid offset should throw "
319                        + "IllegalArgumentException.");
320            } catch (IllegalArgumentException e) {
321            }
322            try {
323                wordIterator.getNextWordEndOnTwoWordBoundary(text.length() + 1);
324                fail("getNextWordEndOnTwoWordBoundary with invalid offset should throw "
325                        + "IllegalArgumentException.");
326            } catch (IllegalArgumentException e) {
327            }
328        }
329
330        {
331            final String text = "abc def-ghi. jkl";
332            WordIterator wordIterator = new WordIterator(Locale.ENGLISH);
333            wordIterator.setCharSequence(text, 0, text.length());
334
335            assertEquals(text.indexOf('c') + 1, wordIterator.getEnd(text.indexOf('a')));
336            assertEquals(text.indexOf('c') + 1, wordIterator.getEnd(text.indexOf('c')));
337            assertEquals(text.indexOf('c') + 1, wordIterator.getEnd(text.indexOf('c') + 1));
338            assertEquals(text.indexOf('f') + 1, wordIterator.getEnd(text.indexOf('d')));
339            assertEquals(text.indexOf('f') + 1, wordIterator.getEnd(text.indexOf('f') + 1));
340            assertEquals(text.indexOf('i') + 1, wordIterator.getEnd(text.indexOf('g')));
341            assertEquals(text.indexOf('i') + 1, wordIterator.getEnd(text.indexOf('i') + 1));
342            assertEquals(BreakIterator.DONE, wordIterator.getEnd(text.indexOf('.') + 1));
343            assertEquals(text.indexOf('l') + 1, wordIterator.getEnd(text.indexOf('j')));
344            assertEquals(text.indexOf('l') + 1, wordIterator.getEnd(text.indexOf('l') + 1));
345
346            for (int i = 0; i < text.length(); i++) {
347                assertEquals(wordIterator.getEnd(i),
348                        wordIterator.getNextWordEndOnTwoWordBoundary(i));
349            }
350        }
351
352        {
353            // Japanese HIRAGANA letter + KATAKANA letters
354            final String text = "\u3042\u30A2\u30A3\u30A4";
355            WordIterator wordIterator = new WordIterator(Locale.JAPANESE);
356            wordIterator.setCharSequence(text, 0, text.length());
357
358            assertEquals(text.indexOf('\u3042') + 1, wordIterator.getEnd(text.indexOf('\u3042')));
359            assertEquals(text.indexOf('\u3042') + 1, wordIterator.getEnd(text.indexOf('\u30A2')));
360            assertEquals(text.indexOf('\u30A4') + 1, wordIterator.getEnd(text.indexOf('\u30A4')));
361            assertEquals(text.indexOf('\u30A4') + 1,
362                    wordIterator.getEnd(text.indexOf('\u30A4') + 1));
363
364            assertEquals(text.indexOf('\u3042') + 1,
365                    wordIterator.getNextWordEndOnTwoWordBoundary(text.indexOf('\u3042')));
366            assertEquals(text.indexOf('\u30A4') + 1,
367                    wordIterator.getNextWordEndOnTwoWordBoundary(text.indexOf('\u30A2')));
368            assertEquals(text.indexOf('\u30A4') + 1,
369                    wordIterator.getNextWordEndOnTwoWordBoundary(text.indexOf('\u30A4')));
370            assertEquals(text.indexOf('\u30A4') + 1,
371                    wordIterator.getNextWordEndOnTwoWordBoundary(text.indexOf('\u30A4') + 1));
372        }
373    }
374
375    @SmallTest
376    public void testGetPunctuationBeginning() {
377        final String text = "abc!? (^^;) def";
378        WordIterator wordIterator = new WordIterator(Locale.ENGLISH);
379        wordIterator.setCharSequence(text, 0, text.length());
380
381        try {
382            wordIterator.getPunctuationBeginning(BreakIterator.DONE);
383            fail("getPunctuationBeginning with invalid offset should throw "
384                    + "IllegalArgumentException.");
385        } catch (IllegalArgumentException e) {
386        }
387        try {
388            wordIterator.getPunctuationBeginning(-2);
389            fail("getPunctuationBeginning with invalid offset should throw "
390                    + "IllegalArgumentException.");
391        } catch (IllegalArgumentException e) {
392        }
393        try {
394            wordIterator.getPunctuationBeginning(text.length() + 1);
395            fail("getPunctuationBeginning with invalid offset should throw "
396                    + "IllegalArgumentException.");
397        } catch (IllegalArgumentException e) {
398        }
399
400        assertEquals(BreakIterator.DONE, wordIterator.getPunctuationBeginning(text.indexOf('a')));
401        assertEquals(BreakIterator.DONE, wordIterator.getPunctuationBeginning(text.indexOf('c')));
402        assertEquals(text.indexOf('!'), wordIterator.getPunctuationBeginning(text.indexOf('!')));
403        assertEquals(text.indexOf('!'),
404                wordIterator.getPunctuationBeginning(text.indexOf('?') + 1));
405        assertEquals(text.indexOf(';'), wordIterator.getPunctuationBeginning(text.indexOf(';')));
406        assertEquals(text.indexOf(';'), wordIterator.getPunctuationBeginning(text.indexOf(')')));
407        assertEquals(text.indexOf(';'), wordIterator.getPunctuationBeginning(text.length()));
408    }
409
410    @SmallTest
411    public void testGetPunctuationEnd() {
412        final String text = "abc!? (^^;) def";
413        WordIterator wordIterator = new WordIterator(Locale.ENGLISH);
414        wordIterator.setCharSequence(text, 0, text.length());
415
416        try {
417            wordIterator.getPunctuationEnd(BreakIterator.DONE);
418            fail("getPunctuationEnd with invalid offset should throw IllegalArgumentException.");
419        } catch (IllegalArgumentException e) {
420        }
421        try {
422            wordIterator.getPunctuationEnd(-2);
423            fail("getPunctuationEnd with invalid offset should throw IllegalArgumentException.");
424        } catch (IllegalArgumentException e) {
425        }
426        try {
427            wordIterator.getPunctuationEnd(text.length() + 1);
428            fail("getPunctuationBeginning with invalid offset should throw "
429                    + "IllegalArgumentException.");
430        } catch (IllegalArgumentException e) {
431        }
432
433        assertEquals(text.indexOf('?') + 1, wordIterator.getPunctuationEnd(text.indexOf('a')));
434        assertEquals(text.indexOf('?') + 1, wordIterator.getPunctuationEnd(text.indexOf('?') + 1));
435        assertEquals(text.indexOf('(') + 1, wordIterator.getPunctuationEnd(text.indexOf('(')));
436        assertEquals(text.indexOf(')') + 1, wordIterator.getPunctuationEnd(text.indexOf('(') + 2));
437        assertEquals(text.indexOf(')') + 1, wordIterator.getPunctuationEnd(text.indexOf(')') + 1));
438        assertEquals(BreakIterator.DONE, wordIterator.getPunctuationEnd(text.indexOf('d')));
439        assertEquals(BreakIterator.DONE, wordIterator.getPunctuationEnd(text.length()));
440    }
441
442    @SmallTest
443    public void testIsAfterPunctuation() {
444        final String text = "abc!? (^^;) def";
445        WordIterator wordIterator = new WordIterator(Locale.ENGLISH);
446        wordIterator.setCharSequence(text, 0, text.length());
447
448        assertFalse(wordIterator.isAfterPunctuation(text.indexOf('a')));
449        assertFalse(wordIterator.isAfterPunctuation(text.indexOf('!')));
450        assertTrue(wordIterator.isAfterPunctuation(text.indexOf('?')));
451        assertTrue(wordIterator.isAfterPunctuation(text.indexOf('?') + 1));
452        assertFalse(wordIterator.isAfterPunctuation(text.indexOf('d')));
453
454        assertFalse(wordIterator.isAfterPunctuation(BreakIterator.DONE));
455        assertFalse(wordIterator.isAfterPunctuation(text.length() + 1));
456    }
457
458    @SmallTest
459    public void testIsOnPunctuation() {
460        final String text = "abc!? (^^;) def";
461        WordIterator wordIterator = new WordIterator(Locale.ENGLISH);
462        wordIterator.setCharSequence(text, 0, text.length());
463
464        assertFalse(wordIterator.isOnPunctuation(text.indexOf('a')));
465        assertTrue(wordIterator.isOnPunctuation(text.indexOf('!')));
466        assertTrue(wordIterator.isOnPunctuation(text.indexOf('?')));
467        assertFalse(wordIterator.isOnPunctuation(text.indexOf('?') + 1));
468        assertTrue(wordIterator.isOnPunctuation(text.indexOf(')')));
469        assertFalse(wordIterator.isOnPunctuation(text.indexOf(')') + 1));
470        assertFalse(wordIterator.isOnPunctuation(text.indexOf('d')));
471
472        assertFalse(wordIterator.isOnPunctuation(BreakIterator.DONE));
473        assertFalse(wordIterator.isOnPunctuation(text.length()));
474        assertFalse(wordIterator.isOnPunctuation(text.length() + 1));
475    }
476}
477