qadevOOo/tests/java/ifc/i18n/_XCharacterClassification.java

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 package ifc.i18n;
  29
  30 import lib.MultiMethodTest;
  31
  32 import com.sun.star.i18n.KParseTokens;
  33 import com.sun.star.i18n.KParseType;
  34 import com.sun.star.i18n.ParseResult;
  35 import com.sun.star.i18n.XCharacterClassification;
  36 import com.sun.star.lang.Locale;
  37
  38 /**
  39  * Testing <code>com.sun.star.i18n.XCharacterClassification</code>
  40  * interface methods:
  41  * <ul>
  42  *  <li><code> toUpper() </code></li>
  43  *  <li><code> toLower() </code></li>
  44  *  <li><code> toTitle() </code></li>
  45  *  <li><code> getType() </code></li>
  46  *  <li><code> getCharacterType() </code></li>
  47  *  <li><code> getStringType() </code></li>
  48  *  <li><code> getCharacterDirection() </code></li>
  49  *  <li><code> getScript() </code></li>
  50  *  <li><code> parseAnyToken() </code></li>
  51  *  <li><code> parsePredefinedToken() </code></li>
  52  * </ul><p>
  53  * Test is <b> NOT </b> multithread compilant. <p>
  54  * @see com.sun.star.i18n.XCharacterClassification
  55  */
  56 public class _XCharacterClassification extends MultiMethodTest {
  57     public XCharacterClassification oObj = null;
  58     public String[] languages = new String[]{"de","en","es","fr","ja","ko","zh"};
  59     public String[] countries = new String[]{"DE","US","ES","FR","JP","KR","CN"};
  60
  61     public String[] charstyles_java = new String[] {"UNASSIGNED","UPPERCASE_LETTER",
  62         "LOWERCASE_LETTER","TITLECASE_LETTER","MODIFIER_LETTER","OTHER_LETTER",
  63         "NON_SPACING_MARK","ENCLOSING_MARK","COMBINING_SPACING_MARK",
  64         "DECIMAL_DIGIT_NUMBER","LETTER_NUMBER","OTHER_NUMBER","SPACE_SEPARATOR",
  65         "LINE_SEPARATOR","PARAGRAPH_SEPARATOR","CONTROL","FORMAT","none17",
  66         "PRIVATE_USE","none19","DASH_PUNCTUATION","START_PUNCTUATION","END_PUNCTUATION",
  67         "CONNECTOR_PUNCTUATION","OTHER_PUNCTUATION","MATH_SYMBOL","CURRENCY_SYMBOL",
  68         "MODIFIER_SYMBOL","OTHER_SYMBOL"};
  69
  70     public String[] charstyles_office = new String[] {"UNASSIGNED","UPPERCASE_LETTER",
  71         "LOWERCASE_LETTER","TITLECASE_LETTER","MODIFIER_LETTER","OTHER_LETTER",
  72         "NON_SPACING_MARK","ENCLOSING_MARK","COMBINING_SPACING_MARK",
  73         "DECIMAL_DIGIT_NUMBER","LETTER_NUMBER","OTHER_NUMBER","SPACE_SEPARATOR",
  74         "LINE_SEPARATOR","PARAGRAPH_SEPARATOR","CONTROL","FORMAT","PRIVATE_USE",
  75         "OTHER_PUNCTUATION","DASH_PUNCTUATION","START_PUNCTUATION","END_PUNCTUATION",
  76         "CONNECTOR_PUNCTUATION",
  77         "OTHER_PUNCTUATION","MATH_SYMBOL","CURRENCY_SYMBOL","MODIFIER_SYMBOL",
  78         "OTHER_SYMBOL","INITIAL_PUNCTUATION","FINAL_PUNCTUATION","GENERAL_TYPES_COUNT"};
  79
  80     public String[] unicode_script = new String[] {"U_BASIC_LATIN","U_LATIN_1_SUPPLEMENT",
  81         "U_LATIN_EXTENDED_A","U_LATIN_EXTENDED_B","U_IPA_EXTENSIONS","U_SPACING_MODIFIER_LETTERS",
  82         "U_COMBINING_DIACRITICAL_MARKS","U_GREEK","U_CYRILLIC","U_ARMENIAN","U_HEBREW",
  83         "U_ARABIC","U_SYRIAC","U_THAANA","U_DEVANAGARI","U_BENGALI","U_GURMUKHI",
  84         "U_GUJARATI","U_ORIYA","U_TAMIL","U_TELUGU","U_KANNADA","U_MALAYALAM",
  85         "U_SINHALA","U_THAI","U_LAO","U_TIBETAN","U_MYANMAR","U_GEORGIAN",
  86         "U_HANGUL_JAMO","U_ETHIOPIC","U_CHEROKEE","U_UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS",
  87         "U_OGHAM","U_RUNIC","U_KHMER","U_MONGOLIAN","U_LATIN_EXTENDED_ADDITIONAL",
  88         "U_GREEK_EXTENDED","U_GENERAL_PUNCTUATION","U_SUPERSCRIPTS_AND_SUBSCRIPTS",
  89         "U_CURRENCY_SYMBOLS","U_COMBINING_MARKS_FOR_SYMBOLS","U_LETTERLIKE_SYMBOLS",
  90         "U_NUMBER_FORMS","U_ARROWS","U_MATHEMATICAL_OPERATORS","U_MISCELLANEOUS_TECHNICAL",
  91         "U_CONTROL_PICTURES","U_OPTICAL_CHARACTER_RECOGNITION","U_ENCLOSED_ALPHANUMERICS",
  92         "U_BOX_DRAWING","U_BLOCK_ELEMENTS","U_GEOMETRIC_SHAPES","U_MISCELLANEOUS_SYMBOLS",
  93         "U_DINGBATS","U_BRAILLE_PATTERNS","U_CJK_RADICALS_SUPPLEMENT","U_KANGXI_RADICALS",
  94         "U_IDEOGRAPHIC_DESCRIPTION_CHARACTERS","U_CJK_SYMBOLS_AND_PUNCTUATION",
  95         "U_HIRAGANA","U_KATAKANA","U_BOPOMOFO","U_HANGUL_COMPATIBILITY_JAMO","U_KANBUN",
  96         "U_BOPOMOFO_EXTENDED","U_ENCLOSED_CJK_LETTERS_AND_MONTHS","U_CJK_COMPATIBILITY",
  97         "U_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A","U_CJK_UNIFIED_IDEOGRAPHS","U_YI_SYLLABLES",
  98         "U_YI_RADICALS","U_HANGUL_SYLLABLES","U_HIGH_SURROGATES","U_HIGH_PRIVATE_USE_SURROGATES",
  99         "U_LOW_SURROGATES","U_PRIVATE_USE_AREA","U_CJK_COMPATIBILITY_IDEOGRAPHS",
 100         "U_ALPHABETIC_PRESENTATION_FORMS","U_ARABIC_PRESENTATION_FORMS_A","U_COMBINING_HALF_MARKS",
 101         "U_CJK_COMPATIBILITY_FORMS","U_SMALL_FORM_VARIANTS","U_ARABIC_PRESENTATION_FORMS_B",
 102         "U_SPECIALS","U_HALFWIDTH_AND_FULLWIDTH_FORMS","U_CHAR_SCRIPT_COUNT","U_NO_SCRIPT"};
 103
 104     /**
 105     * Test calls the method for different locales. Then each result is compared
 106     * with a string, converted to a upper case using
 107     * <code>java.lang.String</code> method <code>toUpperCase()</code>.<p>
 108     * Has <b> OK </b> status if string, returned by the method is equal to
 109     * a string that is returned by String.toUpperCase() for all locales.
 110     */
 111     public void _toUpper() {
 112         boolean res = true;
 113         char[] characters = new char[]{586,65,97,498,721,4588,772,8413,3404};
 114         String toCheck = new String(characters);
 115         String get = "";
 116         String exp = "";
 117
 118         for (int i=0;i<7;i++) {
 119             get = oObj.toUpper(toCheck, 0, toCheck.length(), getLocale(i));
 120             exp = toCheck.toUpperCase(
 121                 new java.util.Locale(languages[i], countries[i]));
 122             res &= get.equals(exp);
 123             if (!res) {
 124                 log.println("FAILED for: language=" + languages[i] +
 125                     " ; country=" + countries[i]);
 126                 log.println("Expected: " + exp);
 127                 log.println("Gained : " + get);
 128             }
 129         }
 130         tRes.tested("toUpper()", res);
 131     }
 132
 133     /**
 134     * Test calls the method for different locales. Then each result is compared
 135     * with a string, converted to a lower case using
 136     * <code>java.lang.String</code> method <code>toLowerCase()</code>.<p>
 137     * Has <b> OK </b> status if string, returned by the method is equal to
 138     * a string that is returned by String.toLowerCase() for all locales.
 139     */
 140     public void _toLower() {
 141         boolean res = true;
 142         char[] characters = new char[]{586,65,97,498,721,4588,772,8413,3404};
 143         String toCheck = new String(characters);
 144         String get = "";
 145         String exp = "";
 146
 147         for (int i=0;i<7;i++) {
 148             get = oObj.toLower(toCheck,0,toCheck.length(),getLocale(i));
 149             exp = toCheck.toLowerCase(
 150                 new java.util.Locale(languages[i],countries[i]));
 151             res &= get.equals(exp);
 152             if (!res) {
 153                 log.println("FAILED for: language=" + languages[i]
 154                     + " ; country=" + countries[i]);
 155                 log.println("Expected: " + exp);
 156                 log.println("Gained : " + get);
 157             }
 158         }
 159         tRes.tested("toLower()", res);
 160     }
 161
 162     /**
 163     * Test calls the method for different locales. Then each result is compared
 164     * with a string, converted to a title case using
 165     * <code>java.lang.Character</code> method <code>toTitleCase()</code>.<p>
 166     * Has <b> OK </b> status if string, returned by the method is equal to
 167     * a string that was converted using Character.toTitleCase() for all locales.
 168     */
 169     public void _toTitle() {
 170         boolean res = true;
 171         String toCheck = new String(new char[]{8112});
 172         String get = "";
 173         String exp = "";
 174
 175         for (int i=0;i<7;i++) {
 176             get = oObj.toTitle(toCheck, 0, 1, getLocale(i));
 177             exp = new String(
 178                 new char[]{Character.toTitleCase(toCheck.toCharArray()[0])});
 179             res &= get.equals(exp);
 180             if (!res) {
 181                 log.println("FAILED for: language=" + languages[i]
 182                     + " ; country=" + countries[i]);
 183                 log.println("Expected: " + exp);
 184                 log.println("Gained : " + get);
 185             }
 186         }
 187         tRes.tested("toTitle()", res);
 188     }
 189
 190     /**
 191     * At first we define <code>int[]</code> and <code>char[]</code> arrays of
 192     * unicode symbol numbers, arranged as sequences, where symbols are sorted
 193     * by type, so the character of <code>i<sup><small>th</small></sup></code>
 194     * type is located on <code>i<sup><small>th</small></sup></code> position.<p>
 195     * Has <b> OK </b> status if for all 30 types the method returns value, that
 196     * is equal to an element number.<p>
 197     * @see com.sun.star.i18n.CharType
 198     */
 199     public void _getType() {
 200         boolean res = true;
 201         char[] characters = new char[]{586,65,97,498,721,4588,772,8413,3404,
 202             48,8544,179,32,8232,8233,144,8204,57344,56320,173,40,41,95,3852,247,
 203             3647,901,3896,171,187};
 204         int[] charsInt = new int[]{586,65,97,498,721,4588,772,8413,3404,48,
 205             8544,179,32,8232,8233,144,8204,57344,56320,173,40,41,95,3852,247,
 206             3647,901,3896,171,187};
 207         String toCheck = new String(characters);
 208
 209         for (int i=0;i<characters.length;i++) {
 210             int get = oObj.getType(toCheck, i);
 211             res &= (charstyles_office[get] == charstyles_office[i]);
 212             if (!res) {
 213                 log.println("Code :" + Integer.toHexString(charsInt[i]));
 214                 log.println("Gained: " + charstyles_office[get]);
 215                 log.println("Expected : " + charstyles_office[i]);
 216             }
 217         }
 218         tRes.tested("getType()", res);
 219     }
 220
 221     /**
 222     * After defining string to be checked and array of expected types, test
 223     * calls the method for each character of a string and for all locales.<p>
 224     * Has <b> OK </b> status if the method returns type, expected for a given
 225     * character and locale.
 226     */
 227     public void _getCharacterType() {
 228         boolean res = true;
 229         String toCheck = "Ab0)";
 230         int[] expected = new int[]{226,228,97,32};
 231
 232         for (int i=0;i<toCheck.length();i++) {
 233             for (int j=1;j<7;j++) {
 234                 int get = oObj.getCharacterType(toCheck, i, getLocale(j));
 235                 res &= (get == expected[i]);
 236                 if (!res) {
 237                     log.println("FAILED for: language=" + languages[j] +
 238                         " ; country=" + countries[j]);
 239                     log.println("Sysmbol :" + toCheck.toCharArray()[i]);
 240                     log.println("Gained: " + get);
 241                     log.println("Expected : " + expected[i]);
 242                 }
 243             }
 244         }
 245         tRes.tested("getCharacterType()", res);
 246     }
 247
 248     /**
 249     * After defining array of strings to be checked and array of expected types,
 250     * test calls the method for each string of an array and for all locales.<p>
 251     * Has <b> OK </b> status if the method returns type, expected for a given
 252     * string and locale.
 253     */
 254     public void _getStringType() {
 255         boolean res = true;
 256         String[] toCheck = new String[]{"01234","AAAAA","bbbbb","AA()bb"};
 257         int[] exp = new int[]{97,226,228,230};
 258
 259         for (int j=0;j<toCheck.length;j++) {
 260             for (int i=0;i<7;i++) {
 261                 int get = oObj.getStringType(toCheck[j], 0,
 262                     toCheck[j].length(), getLocale(i));
 263                 res &= (get == exp[j]);
 264                 if (!res) {
 265                     log.println("FAILED for: language=" + languages[i] +
 266                         " ; country=" + countries[i]);
 267                     log.println("Expected: " + exp[j]);
 268                     log.println("Gained : " + get);
 269                 }
 270             }
 271         }
 272         tRes.tested("getStringType()", res);
 273     }
 274
 275     /**
 276     * After string to be checked is initialized (all symbols are sorted
 277     * by direction, so the character of <code>i<sup><small>th</small></sup></code>
 278     * direction is located on <code>i<sup><small>th</small></sup></code>
 279     * position), test calls the method for every character of that string. <p>
 280     * Has <b> OK </b> status if the method returns direction, that's equal to
 281     * a symbol position in the string.
 282     */
 283     public void _getCharacterDirection() {
 284         boolean res = true;
 285         String toCheck = new String(new char[]{65,1470,48,47,35,1632,44,10,
 286                                 9,12,33,8234,8237,1563,8235,8238,8236,768,1});
 287         for (short i=0;i<19;i++) {
 288             short get = oObj.getCharacterDirection(toCheck, i);
 289             res &= (get == i);
 290             if (!res) {
 291                 log.println("Code :" + toCheck.toCharArray()[i]);
 292                 log.println("Gained: " + get);
 293                 log.println("Expected: " + i);
 294             }
 295         }
 296         tRes.tested("getCharacterDirection()", res);
 297     }
 298
 299     /**
 300     * At first we define <code>int[]</code> and <code>char[]</code> arrays of
 301     * unicode symbol numbers, arranged as sequences, where symbols are sorted
 302     * by type, so the character of <code>i<sup><small>th</small></sup></code>
 303     * type is located on <code>i<sup><small>th</small></sup></code> position.<p>
 304     * Has <b> OK </b> status if for each character method returns value, that
 305     * is equal to a number where element is located in array. Also method has
 306     * <b> OK </b> status for symbol with code 55296, because it doesn't work
 307     * since it hasn't the right neighborhood.<p>
 308     * @see http://ppewww.ph.gla.ac.uk/~flavell/unicode/unidata.html
 309     */
 310     public void _getScript() {
 311         boolean res = true;
 312         char[] characters = new char[]{65,128,256,384,592,750,773,924,1030,1331,1448,
 313             1569,1792,1936,2313,2465,2570,2707,2822,2972,3079,3240,3337,3464,3590,
 314             3745,3906,4097,4274,4357,4621,5040,5200,5776,5806,6030,6155,7683,7943,
 315             8202,8319,8352,8413,8452,8545,8616,8715,8965,9217,9281,9336,9474,9608,9719,
 316             9734,9999,10247,11911,12034,12274,12294,12358,12456,12552,12605,12688,12727,
 317             12806,13065,13312,19968,40964,42152,44032,55296,56192,56320,57344,63744,
 318             64257,64370,65056,65073,65131,65146,65532,65288};
 319         int[] charsInt = new int[]{65,128,256,384,592,750,773,924,1030,1331,1448,
 320             1569,1792,1936,2313,2465,2570,2707,2822,2972,3079,3240,3337,3464,3590,
 321             3745,3906,4097,4274,4357,4621,5040,5200,5776,5806,6030,6155,7683,7943,
 322             8202,8319,8352,8413,8452,8545,8616,8715,8965,9217,9281,9336,9474,9608,9719,
 323             9734,9999,10247,11911,12034,12274,12294,12358,12456,12552,12605,12688,12727,
 324             12806,13065,13312,19968,40964,42152,44032,55296,56192,56320,57344,63744,
 325             64257,64370,65056,65073,65131,65146,65532,65288};
 326         String toCheck = new String(characters);
 327
 328         for (int i=0;i<characters.length;i++) {
 329             int get = oObj.getScript(toCheck, i);
 330             res &= (get == i);
 331             //The HIGH_SURROGATE 55296 doesn't work since it hasn't the right
 332             //neighborhood
 333             if (toCheck.substring(i, i + 1).hashCode() == 55296) res = true;
 334             if (!res) {
 335                 log.println("-- " + toCheck.substring(i, i + 1).hashCode());
 336                 log.println("Code: " + Integer.toHexString(charsInt[i]));
 337                 log.println("Gained: " + unicode_script[get]);
 338                 log.println("Expected: " + unicode_script[i]);
 339             }
 340         }
 341         tRes.tested("getScript()", res);
 342     }
 343
 344     /**
 345     * After defining a string to be parsed and parse conditions (flags), test
 346     * calls the method for different locales three times with different parameters,
 347     * checking result after every call.  <p>
 348     * Has <b> OK </b> status if the method returns right results all three
 349     * times.
 350     */
 351     public void _parseAnyToken() {
 352         int nStartFlags = KParseTokens.ANY_ALPHA | KParseTokens.ASC_UNDERSCORE;
 353         int nContFlags = KParseTokens.ANY_ALNUM | KParseTokens.ASC_UNDERSCORE
 354                         | KParseTokens.ASC_DOT;
 355         String toCheck = " 18 i18n ^";
 356         ParseResult pRes = null;
 357         boolean res = true;
 358
 359         for (int i=0;i<7;i++) {
 360             pRes = oObj.parseAnyToken(toCheck, 1, getLocale(i),
 361                 nStartFlags, "", nContFlags, "");
 362             res = ( (pRes.CharLen==2)
 363                  && (pRes.TokenType==32)
 364                  && (pRes.Value==18.0) );
 365             pRes = oObj.parseAnyToken(toCheck, 4, getLocale(i),
 366                 nStartFlags, "", nContFlags, "");
 367             res &= ( (pRes.CharLen==4)
 368                   && (pRes.TokenType==4)
 369                   && (pRes.Value==0.0) );
 370             pRes = oObj.parseAnyToken(toCheck, 9, getLocale(i),
 371                 nStartFlags, "", nContFlags, "");
 372             res &= ( (pRes.CharLen==1)
 373                   && (pRes.TokenType==1)
 374                   && (pRes.Value==0.0) );
 375         }
 376         tRes.tested("parseAnyToken()", res);
 377     }
 378
 379     /**
 380     * After defining a string to be parsed and parse conditions (flags), test
 381     * calls the method for different locales two times with different parameters,
 382     * checking result after every call. <p>
 383     * Has <b> OK </b> status if the method returns right results.
 384     */
 385     public void _parsePredefinedToken() {
 386         int nStartFlags = KParseTokens.ANY_ALPHA | KParseTokens.ASC_UNDERSCORE;
 387         int nContFlags = nStartFlags;
 388         String toCheck = " 18 int";
 389         ParseResult pRes = null;
 390         boolean res = true;
 391
 392         for (int i=0;i<7;i++) {
 393             pRes = oObj.parsePredefinedToken(KParseType.IDENTNAME, toCheck,
 394                 1, getLocale(i), nStartFlags, "", nContFlags, "");
 395             res = (pRes.CharLen==0);
 396             pRes = oObj.parsePredefinedToken(KParseType.IDENTNAME, toCheck,
 397                 4, getLocale(i), nStartFlags, "", nContFlags, "");
 398             res &= ( (pRes.CharLen==3)
 399                   && (pRes.TokenType==4)
 400                   && (pRes.Value==0.0) );
 401         }
 402         tRes.tested("parsePredefinedToken()", res);
 403     }
 404
 405
 406     /**
 407     * Method returns locale for a given language and country.
 408     * @param localeIndex index of needed locale.
 409     */
 410     private Locale getLocale(int k) {
 411         return new Locale(languages[k],countries[k],"");
 412     }
 413
 414
 415 } // end XCharacterClassification
 416