Home | History | Annotate | Download | only in normalizer 
      1 /* GENERATED SOURCE. DO NOT MODIFY. */
      2 //  2016 and later: Unicode, Inc. and others.
      3 // License & terms of use: http://www.unicode.org/copyright.html#License
      4 /*
      5  *******************************************************************************
      6  * Copyright (C) 1996-2010, International Business Machines Corporation and    *
      7  * others. All Rights Reserved.                                                *
      8  *******************************************************************************
      9  */
     10 package android.icu.dev.test.normalizer;
     11 
     12 import org.junit.Test;
     13 import org.junit.runner.RunWith;
     14 import org.junit.runners.JUnit4;
     15 
     16 import android.icu.dev.test.TestFmwk;
     17 import android.icu.impl.Utility;
     18 import android.icu.lang.UCharacter;
     19 import android.icu.lang.UProperty;
     20 import android.icu.text.ComposedCharIter;
     21 import android.icu.text.Normalizer;
     22 import android.icu.text.StringCharacterIterator;
     23 import android.icu.testsharding.MainTestShard;
     24 
     25 @MainTestShard
     26 @RunWith(JUnit4.class)
     27 public class TestDeprecatedNormalizerAPI extends TestFmwk
     28 {
     29     public TestDeprecatedNormalizerAPI() {
     30     }
     31 
     32     @Test
     33     public void TestNormalizerAPI(){
     34          // instantiate a Normalizer from a CharacterIterator
     35         String s=Utility.unescape("a\u0308\uac00\\U0002f800");
     36         // make s a bit longer and more interesting
     37         java.text.CharacterIterator iter = new StringCharacterIterator(s+s);
     38         //test deprecated constructors
     39         Normalizer norm = new Normalizer(iter, Normalizer.NFC,0);
     40         if(norm.next()!=0xe4) {
     41             errln("error in Normalizer(CharacterIterator).next()");
     42         }
     43         Normalizer norm2 = new Normalizer(s,Normalizer.NFC,0);
     44         if(norm2.next()!=0xe4) {
     45             errln("error in Normalizer(CharacterIterator).next()");
     46         }
     47         // test clone(), ==, and hashCode()
     48         Normalizer clone=(Normalizer)norm.clone();
     49         if(clone.getBeginIndex()!= norm.getBeginIndex()){
     50            errln("error in Normalizer.getBeginIndex()");
     51         }
     52 
     53         if(clone.getEndIndex()!= norm.getEndIndex()){
     54            errln("error in Normalizer.getEndIndex()");
     55         }
     56         // test setOption() and getOption()
     57         clone.setOption(0xaa0000, true);
     58         clone.setOption(0x20000, false);
     59         if(clone.getOption(0x880000) ==0|| clone.getOption(0x20000)==1) {
     60            errln("error in Normalizer::setOption() or Normalizer::getOption()");
     61         }
     62         //test deprecated normalize method
     63         Normalizer.normalize(s,Normalizer.NFC,0);
     64         //test deprecated compose method
     65         Normalizer.compose(s,false,0);
     66         //test deprecated decompose method
     67         Normalizer.decompose(s,false,0);
     68 
     69     }
     70 
     71     /**
     72      * Run through all of the characters returned by a composed-char iterator
     73      * and make sure that:
     74      * <ul>
     75      * <li>a) They do indeed have decompositions.
     76      * <li>b) The decomposition according to the iterator is the same as
     77      *          returned by Normalizer.decompose().
     78      * <li>c) All characters <em>not</em> returned by the iterator do not
     79      *          have decompositions.
     80      * </ul>
     81      */
     82     @Test
     83     public void TestComposedCharIter() {
     84         doTestComposedChars(false);
     85     }
     86 
     87     private void doTestComposedChars(boolean compat) {
     88         int options = Normalizer.IGNORE_HANGUL;
     89         ComposedCharIter iter = new ComposedCharIter(compat, options);
     90 
     91         char lastChar = 0;
     92 
     93         while (iter.hasNext()) {
     94             char ch = iter.next();
     95 
     96             // Test all characters between the last one and this one to make
     97             // sure that they don't have decompositions
     98             assertNoDecomp(lastChar, ch, compat, options);
     99             lastChar = ch;
    100 
    101             // Now make sure that the decompositions for this character
    102             // make sense
    103             String chString   = new StringBuffer().append(ch).toString();
    104             String iterDecomp = iter.decomposition();
    105             String normDecomp = Normalizer.decompose(chString, compat);
    106 
    107             if (iterDecomp.equals(chString)) {
    108                 errln("ERROR: " + hex(ch) + " has identical decomp");
    109             }
    110             else if (!iterDecomp.equals(normDecomp)) {
    111                 errln("ERROR: Normalizer decomp for " + hex(ch) + " (" + hex(normDecomp) + ")"
    112                     + " != iter decomp (" + hex(iterDecomp) + ")" );
    113             }
    114         }
    115         assertNoDecomp(lastChar, '\uFFFF', compat, options);
    116     }
    117 
    118     void assertNoDecomp(char start, char limit, boolean compat, int options)
    119     {
    120         for (char x = ++start; x < limit; x++) {
    121             String xString   = new StringBuffer().append(x).toString();
    122             String decomp = Normalizer.decompose(xString, compat);
    123             if (!decomp.equals(xString)) {
    124                 errln("ERROR: " + hex(x) + " has decomposition (" + hex(decomp) + ")"
    125                     + " but was not returned by iterator");
    126             }
    127         }
    128     }
    129 
    130 
    131     @Test
    132     public void TestRoundTrip() {
    133         int options = Normalizer.IGNORE_HANGUL;
    134         boolean compat = false;
    135 
    136         ComposedCharIter iter = new ComposedCharIter(false, options);
    137         while (iter.hasNext()) {
    138             final char ch = iter.next();
    139 
    140             String chStr = String.valueOf(ch);
    141             String decomp = iter.decomposition();
    142             String comp = Normalizer.compose(decomp, compat);
    143 
    144             if (UCharacter.hasBinaryProperty(ch, UProperty.FULL_COMPOSITION_EXCLUSION)) {
    145                 logln("Skipped excluded char " + hex(ch) + " (" + UCharacter.getName(ch) + ")" );
    146                 continue;
    147             }
    148 
    149             // Avoid disparaged characters
    150             if (decomp.length() == 4) continue;
    151 
    152             if (!comp.equals(chStr)) {
    153                 errln("ERROR: Round trip invalid: " + hex(chStr) + " --> " + hex(decomp)
    154                     + " --> " + hex(comp));
    155 
    156                 errln("  char decomp is '" + decomp + "'");
    157             }
    158         }
    159     }
    160 }
    161