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        assertEquals(BreakIterator.DONE, iterator.following(TEXT.length()));
98    }
99
100    public void testIsBoundary() {
101        try {
102            iterator.isBoundary(2);
103            fail("should throw illegal argument exception");
104        } catch (IllegalArgumentException e) {
105        }
106        iterator.setText(TEXT);
107        assertTrue(iterator.isBoundary(2));
108        assertFalse(iterator.isBoundary(1));
109        assertTrue(iterator.isBoundary(0));
110        try {
111            iterator.isBoundary(-1);
112            fail("should throw illegal argument exception");
113        } catch (IllegalArgumentException e) {
114        }
115        assertTrue(iterator.isBoundary(TEXT.length()));
116    }
117
118    public void testLast() {
119        assertEquals(0, iterator.last());
120        iterator.setText(TEXT);
121        assertEquals(TEXT.length(), iterator.last());
122    }
123
124    /*
125     * Class under test for int next(int)
126     */
127    public void testNextint() {
128        assertEquals(BreakIterator.DONE, iterator.next(3));
129        iterator.setText(TEXT);
130        assertEquals(4, iterator.next(3));
131        assertEquals(24, iterator.next(20));
132        assertEquals(23, iterator.next(-1));
133        assertEquals(-1, iterator.next(TEXT.length()));
134    }
135
136    public void testPreceding() {
137        try {
138            iterator.preceding(2);
139            fail("should throw illegal argument exception");
140        } catch (IllegalArgumentException e) {
141        }
142        iterator.setText(TEXT);
143        assertEquals(0, iterator.preceding(2));
144        assertEquals(2, iterator.preceding(3));
145        assertEquals(16, iterator.preceding(17));
146        assertEquals(17, iterator.preceding(18));
147        assertEquals(18, iterator.preceding(19));
148        try {
149            iterator.preceding(-1);
150            fail("should throw illegal argument exception");
151        } catch (IllegalArgumentException e) {
152        }
153        assertEquals(TEXT.length() - 1, iterator.preceding(TEXT.length()));
154        assertEquals(BreakIterator.DONE, iterator.preceding(0));
155    }
156
157    public void testPrevious() {
158        assertEquals(-1, iterator.previous());
159        iterator.setText(TEXT);
160        assertEquals(-1, iterator.previous());
161        iterator.last();
162        assertEquals(TEXT.length() - 1, iterator.previous());
163    }
164
165    public void testGetAvailableLocales() {
166        Locale[] locales = BreakIterator.getAvailableLocales();
167        assertTrue(locales.length > 0);
168    }
169
170    /*
171     * Class under test for BreakIterator getCharacterInstance()
172     */
173    public void testGetCharacterInstance() {
174        BreakIterator.getCharacterInstance();
175    }
176
177    /*
178     * Class under test for BreakIterator getCharacterInstance(Locale)
179     */
180    public void testGetCharacterInstanceLocale() {
181        BreakIterator it = BreakIterator.getCharacterInstance(Locale.US);
182        BreakIterator it2 = BreakIterator.getCharacterInstance(Locale.CHINA);
183        assertEquals(it, it2);
184    }
185
186    /*
187     * Class under test for BreakIterator getLineInstance()
188     */
189    public void testGetLineInstance() {
190        BreakIterator it = BreakIterator.getLineInstance();
191        assertNotNull(it);
192    }
193
194    /*
195     * Class under test for BreakIterator getLineInstance(Locale)
196     */
197    public void testGetLineInstanceLocale() {
198        BreakIterator it = BreakIterator.getLineInstance(Locale.US);
199        assertNotNull(it);
200        BreakIterator.getLineInstance(new Locale("bad locale"));
201    }
202
203    /*
204     * Class under test for BreakIterator getSentenceInstance()
205     */
206    public void testGetSentenceInstance() {
207        BreakIterator it = BreakIterator.getSentenceInstance();
208        assertNotNull(it);
209    }
210
211    /*
212     * Class under test for BreakIterator getSentenceInstance(Locale)
213     */
214    public void testGetSentenceInstanceLocale() {
215        BreakIterator it = BreakIterator.getSentenceInstance(Locale.US);
216        assertNotNull(it);
217    }
218
219    public void testGetText() {
220        assertEquals(new StringCharacterIterator(""), iterator.getText());
221        iterator.setText(TEXT);
222        assertEquals(new StringCharacterIterator(TEXT), iterator.getText());
223    }
224
225    /*
226     * Class under test for BreakIterator getWordInstance()
227     */
228    public void testGetWordInstance() {
229        BreakIterator it = BreakIterator.getWordInstance();
230        assertNotNull(it);
231    }
232
233    /*
234     * Class under test for BreakIterator getWordInstance(Locale)
235     */
236    public void testGetWordInstanceLocale() {
237        BreakIterator it = BreakIterator.getWordInstance(Locale.US);
238        assertNotNull(it);
239    }
240
241    /*
242     * Class under test for void setText(CharacterIterator)
243     */
244    public void testSetTextCharacterIterator() {
245        try {
246            iterator.setText((CharacterIterator) null);
247            fail();
248        } catch (NullPointerException e) {
249        }
250        CharacterIterator it = new StringCharacterIterator("abc");
251        iterator.setText(it);
252        assertSame(it, iterator.getText());
253    }
254
255    /*
256     * Class under test for void setText(String)
257     */
258    public void testSetTextString() {
259        try {
260            iterator.setText((String) null);
261            fail();
262        } catch (NullPointerException e) {
263        }
264        iterator.setText("abc");
265        CharacterIterator it = new StringCharacterIterator("abc");
266        assertEquals(it, iterator.getText());
267    }
268
269	public void test_next() {
270		// Regression test for HARMONY-30
271		BreakIterator bi = BreakIterator.getWordInstance(Locale.US);
272		bi.setText("This is the test, WordInstance");
273		int n = bi.first();
274		n = bi.next();
275		assertEquals("Assert 0: next() returns incorrect value ", 4, n);
276
277        assertEquals(BreakIterator.DONE, iterator.next());
278        iterator.setText(TEXT);
279        assertEquals(2, iterator.next());
280	}
281
282	/**
283	 * @tests java.text.BreakIterator#getCharacterInstance(Locale)
284	 */
285    public void testGetCharacterInstanceLocale_NPE() {
286        // Regression for HARMONY-265
287        try {
288            BreakIterator.getCharacterInstance(null);
289            fail("BreakIterator.getCharacterInstance(null); should throw NullPointerException");
290        } catch (NullPointerException e) {
291        }
292    }
293
294    public void testGetLineInstanceLocale_NPE() {
295        try {
296            BreakIterator.getLineInstance(null);
297            fail("BreakIterator.getLineInstance(null); should throw NullPointerException");
298        } catch (NullPointerException e) {
299        }
300    }
301
302    public void testGetSentenceInstanceLocale_NPE() {
303        try {
304            BreakIterator.getSentenceInstance(null);
305            fail("BreakIterator.getSentenceInstance(null); should throw NullPointerException");
306        } catch (NullPointerException e) {
307        }
308    }
309
310    public void testGetWordInstanceLocale_NPE() {
311        try {
312            BreakIterator.getWordInstance(null);
313            fail("BreakIterator.getWordInstance(null); should throw NullPointerException");
314        } catch (NullPointerException e) {
315        }
316    }
317}
318