Home | History | Annotate | Download | only in text 
      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 
     18 package org.apache.harmony.tests.java.text;
     19 
     20 import java.text.BreakIterator;
     21 import java.text.CharacterIterator;
     22 import java.text.StringCharacterIterator;
     23 import java.util.Locale;
     24 
     25 import junit.framework.TestCase;
     26 
     27 public 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