1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
13 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
14 * License for the specific language governing permissions and limitations under
15 * the License.
16 */
17
18package org.apache.harmony.text.tests.java.text;
19
20import java.text.BreakIterator;
21import java.text.CharacterIterator;
22import java.text.StringCharacterIterator;
23import java.util.Locale;
24
25import junit.framework.TestCase;
26
27public class BreakIteratorTest extends TestCase {
28
29    private static final String TEXT = "a\u0308abc def, gh-12i?jkl.mno?";
30
31    BreakIterator iterator;
32
33    /*
34     * @see TestCase#setUp()
35     */
36    protected void setUp() throws Exception {
37        super.setUp();
38        iterator = BreakIterator.getCharacterInstance(Locale.US);
39    }
40
41    public void testConsts() {
42        assertEquals(-1, BreakIterator.DONE);
43    }
44
45    public void testCache() {
46        BreakIterator newOne = BreakIterator.getCharacterInstance(Locale.US);
47        assertNotSame(newOne, iterator);
48        assertEquals(newOne, iterator);
49
50        newOne = BreakIterator.getCharacterInstance();
51        assertEquals(newOne, iterator);
52
53        newOne = BreakIterator.getCharacterInstance(Locale.CHINA);
54        assertEquals(newOne, iterator);
55
56        BreakIterator wordIterator = BreakIterator.getWordInstance();
57        assertFalse(wordIterator.equals(iterator));
58
59        BreakIterator lineIterator = BreakIterator.getLineInstance();
60        assertFalse(lineIterator.equals(iterator));
61
62        BreakIterator senteIterator = BreakIterator.getSentenceInstance();
63        assertFalse(senteIterator.equals(iterator));
64    }
65
66    public void testClone() {
67        BreakIterator cloned = (BreakIterator) iterator.clone();
68        assertNotSame(cloned, iterator);
69        assertEquals(cloned, iterator);
70    }
71
72    public void testCurrent() {
73        assertEquals(0, iterator.current());
74        iterator.setText(TEXT);
75        assertEquals(iterator.first(), iterator.current());
76    }
77
78    public void testFirst() {
79        assertEquals(0, iterator.first());
80        iterator.setText(TEXT);
81        assertEquals(0, iterator.first());
82    }
83
84    public void testFollowing() {
85        try {
86            iterator.following(1);
87            fail("should throw illegal argument exception");
88        } catch (IllegalArgumentException e) {
89        }
90        iterator.setText(TEXT);
91        assertEquals(2, iterator.following(1));
92        try {
93            assertEquals(0, iterator.following(-1));
94            fail("should throw illegal argument exception");
95        } catch (IllegalArgumentException e) {
96        }
97        try {
98            iterator.following(TEXT.length());
99            fail("should throw illegal argument exception");
100        } catch (IllegalArgumentException e) {
101        }
102    }
103
104    public void testIsBoundary() {
105        try {
106            iterator.isBoundary(2);
107            fail("should throw illegal argument exception");
108        } catch (IllegalArgumentException e) {
109        }
110        iterator.setText(TEXT);
111        assertTrue(iterator.isBoundary(2));
112        assertFalse(iterator.isBoundary(1));
113        assertTrue(iterator.isBoundary(0));
114        try {
115            iterator.isBoundary(-1);
116            fail("should throw illegal argument exception");
117        } catch (IllegalArgumentException e) {
118        }
119        try {
120            iterator.isBoundary(TEXT.length());
121            fail("should throw illegal argument exception");
122        } catch (IllegalArgumentException e) {
123        }
124    }
125
126    public void testLast() {
127        assertEquals(0, iterator.last());
128        iterator.setText(TEXT);
129        assertEquals(TEXT.length(), iterator.last());
130    }
131
132    /*
133     * Class under test for int next(int)
134     */
135    public void testNextint() {
136        assertEquals(BreakIterator.DONE, iterator.next(3));
137        iterator.setText(TEXT);
138        assertEquals(4, iterator.next(3));
139        assertEquals(24, iterator.next(20));
140        assertEquals(23, iterator.next(-1));
141        assertEquals(-1, iterator.next(TEXT.length()));
142    }
143
144    public void testPreceding() {
145        try {
146            iterator.preceding(2);
147            fail("should throw illegal argument exception");
148        } catch (IllegalArgumentException e) {
149        }
150        iterator.setText(TEXT);
151        assertEquals(0, iterator.preceding(2));
152        assertEquals(2, iterator.preceding(3));
153        assertEquals(16, iterator.preceding(17));
154        assertEquals(17, iterator.preceding(18));
155        assertEquals(18, iterator.preceding(19));
156        try {
157            iterator.preceding(-1);
158            fail("should throw illegal argument exception");
159        } catch (IllegalArgumentException e) {
160        }
161        try {
162            iterator.preceding(TEXT.length());
163            fail("should throw illegal argument exception");
164        } catch (IllegalArgumentException e) {
165        }
166    }
167
168    public void testPrevious() {
169        assertEquals(-1, iterator.previous());
170        iterator.setText(TEXT);
171        assertEquals(-1, iterator.previous());
172        iterator.last();
173        assertEquals(TEXT.length() - 1, iterator.previous());
174    }
175
176    public void testGetAvailableLocales() {
177        Locale[] locales = BreakIterator.getAvailableLocales();
178        assertTrue(locales.length > 0);
179    }
180
181    /*
182     * Class under test for BreakIterator getCharacterInstance()
183     */
184    public void testGetCharacterInstance() {
185        BreakIterator.getCharacterInstance();
186    }
187
188    /*
189     * Class under test for BreakIterator getCharacterInstance(Locale)
190     */
191    public void testGetCharacterInstanceLocale() {
192        BreakIterator it = BreakIterator.getCharacterInstance(Locale.US);
193        BreakIterator it2 = BreakIterator.getCharacterInstance(Locale.CHINA);
194        assertEquals(it, it2);
195    }
196
197    /*
198     * Class under test for BreakIterator getLineInstance()
199     */
200    public void testGetLineInstance() {
201        BreakIterator it = BreakIterator.getLineInstance();
202        assertNotNull(it);
203    }
204
205    /*
206     * Class under test for BreakIterator getLineInstance(Locale)
207     */
208    public void testGetLineInstanceLocale() {
209        BreakIterator it = BreakIterator.getLineInstance(Locale.US);
210        assertNotNull(it);
211        BreakIterator.getLineInstance(new Locale("bad locale"));
212    }
213
214    /*
215     * Class under test for BreakIterator getSentenceInstance()
216     */
217    public void testGetSentenceInstance() {
218        BreakIterator it = BreakIterator.getSentenceInstance();
219        assertNotNull(it);
220    }
221
222    /*
223     * Class under test for BreakIterator getSentenceInstance(Locale)
224     */
225    public void testGetSentenceInstanceLocale() {
226        BreakIterator it = BreakIterator.getSentenceInstance(Locale.US);
227        assertNotNull(it);
228    }
229
230    public void testGetText() {
231        assertEquals(new StringCharacterIterator(""), iterator.getText());
232        iterator.setText(TEXT);
233        assertEquals(new StringCharacterIterator(TEXT), iterator.getText());
234    }
235
236    /*
237     * Class under test for BreakIterator getWordInstance()
238     */
239    public void testGetWordInstance() {
240        BreakIterator it = BreakIterator.getWordInstance();
241        assertNotNull(it);
242    }
243
244    /*
245     * Class under test for BreakIterator getWordInstance(Locale)
246     */
247    public void testGetWordInstanceLocale() {
248        BreakIterator it = BreakIterator.getWordInstance(Locale.US);
249        assertNotNull(it);
250    }
251
252    /*
253     * Class under test for void setText(CharacterIterator)
254     */
255    public void testSetTextCharacterIterator() {
256        try {
257            iterator.setText((CharacterIterator) null);
258            fail();
259        } catch (NullPointerException e) {
260        }
261        CharacterIterator it = new StringCharacterIterator("abc");
262        iterator.setText(it);
263        assertSame(it, iterator.getText());
264    }
265
266    /*
267     * Class under test for void setText(String)
268     */
269    public void testSetTextString() {
270        try {
271            iterator.setText((String) null);
272            fail();
273        } catch (NullPointerException e) {
274        }
275        iterator.setText("abc");
276        CharacterIterator it = new StringCharacterIterator("abc");
277        assertEquals(it, iterator.getText());
278    }
279
280	public void test_next() {
281		// Regression test for HARMONY-30
282		BreakIterator bi = BreakIterator.getWordInstance(Locale.US);
283		bi.setText("This is the test, WordInstance");
284		int n = bi.first();
285		n = bi.next();
286		assertEquals("Assert 0: next() returns incorrect value ", 4, n);
287
288        assertEquals(BreakIterator.DONE, iterator.next());
289        iterator.setText(TEXT);
290        assertEquals(2, iterator.next());
291	}
292
293	/**
294	 * @tests java.text.BreakIterator#getCharacterInstance(Locale)
295	 */
296    public void testGetCharacterInstanceLocale_NPE() {
297        // Regression for HARMONY-265
298        try {
299            BreakIterator.getCharacterInstance(null);
300            fail("BreakIterator.getCharacterInstance(null); should throw NullPointerException");
301        } catch (NullPointerException e) {
302        }
303    }
304
305    public void testGetLineInstanceLocale_NPE() {
306        try {
307            BreakIterator.getLineInstance(null);
308            fail("BreakIterator.getLineInstance(null); should throw NullPointerException");
309        } catch (NullPointerException e) {
310        }
311    }
312
313    public void testGetSentenceInstanceLocale_NPE() {
314        try {
315            BreakIterator.getSentenceInstance(null);
316            fail("BreakIterator.getSentenceInstance(null); should throw NullPointerException");
317        } catch (NullPointerException e) {
318        }
319    }
320
321    public void testGetWordInstanceLocale_NPE() {
322        try {
323            BreakIterator.getWordInstance(null);
324            fail("BreakIterator.getWordInstance(null); should throw NullPointerException");
325        } catch (NullPointerException e) {
326        }
327    }
328}
329