| /** |
| ******************************************************************************* |
| * Copyright (C) 1996-2001, International Business Machines Corporation and * |
| * others. All Rights Reserved. * |
| ******************************************************************************* |
| * |
| * $Source: /xsrl/Nsvn/icu/icu4j/src/com/ibm/icu/dev/test/lang/UCharacterCaseTest.java,v $ |
| * $Date: 2002/10/03 23:42:02 $ |
| * $Revision: 1.6 $ |
| * |
| ******************************************************************************* |
| */ |
| |
| package com.ibm.icu.dev.test.lang; |
| |
| import com.ibm.icu.dev.test.TestFmwk; |
| import com.ibm.icu.dev.test.TestUtil; |
| import com.ibm.icu.lang.UCharacter; |
| import com.ibm.icu.text.UTF16; |
| import com.ibm.icu.text.BreakIterator; |
| import com.ibm.icu.impl.Utility; |
| import java.util.Locale; |
| import java.io.BufferedReader; |
| import java.util.Vector; |
| |
| /** |
| * <p>Testing character casing</p> |
| * <p>Mostly following the test cases in strcase.cpp for ICU</p> |
| * @author Syn Wee Quek |
| * @since march 14 2002 |
| */ |
| public final class UCharacterCaseTest extends TestFmwk |
| { |
| // constructor ----------------------------------------------------------- |
| |
| /** |
| * Constructor |
| */ |
| public UCharacterCaseTest() |
| { |
| } |
| |
| // public methods -------------------------------------------------------- |
| |
| public static void main(String[] arg) |
| { |
| try |
| { |
| UCharacterCaseTest test = new UCharacterCaseTest(); |
| test.run(arg); |
| } |
| catch (Exception e) |
| { |
| e.printStackTrace(); |
| } |
| } |
| |
| /** |
| * Testing the uppercase and lowercase function of UCharacter |
| */ |
| public void TestCharacter() |
| { |
| for (int i = 0; i < CHARACTER_LOWER_.length; i ++) { |
| if (UCharacter.isLetter(CHARACTER_LOWER_[i]) && |
| !UCharacter.isLowerCase(CHARACTER_LOWER_[i])) { |
| errln("FAIL isLowerCase test for \\u" + |
| hex(CHARACTER_LOWER_[i])); |
| break; |
| } |
| if (UCharacter.isLetter(CHARACTER_UPPER_[i]) && |
| !(UCharacter.isUpperCase(CHARACTER_UPPER_[i]) || |
| UCharacter.isTitleCase(CHARACTER_UPPER_[i]))) { |
| errln("FAIL isUpperCase test for \\u" + |
| hex(CHARACTER_UPPER_[i])); |
| break; |
| } |
| if (CHARACTER_LOWER_[i] != |
| UCharacter.toLowerCase(CHARACTER_UPPER_[i]) || |
| (CHARACTER_UPPER_[i] != |
| UCharacter.toUpperCase(CHARACTER_LOWER_[i]) && |
| CHARACTER_UPPER_[i] != |
| UCharacter.toTitleCase(CHARACTER_LOWER_[i]))) { |
| errln("FAIL case conversion test for \\u" + |
| hex(CHARACTER_UPPER_[i]) + |
| " to \\u" + hex(CHARACTER_LOWER_[i])); |
| break; |
| } |
| if (CHARACTER_LOWER_[i] != |
| UCharacter.toLowerCase(CHARACTER_LOWER_[i])) { |
| errln("FAIL lower case conversion test for \\u" + |
| hex(CHARACTER_LOWER_[i])); |
| break; |
| } |
| if (CHARACTER_UPPER_[i] != |
| UCharacter.toUpperCase(CHARACTER_UPPER_[i]) && |
| CHARACTER_UPPER_[i] != |
| UCharacter.toTitleCase(CHARACTER_UPPER_[i])) { |
| errln("FAIL upper case conversion test for \\u" + |
| hex(CHARACTER_UPPER_[i])); |
| break; |
| } |
| logln("Ok \\u" + hex(CHARACTER_UPPER_[i]) + " and \\u" + |
| hex(CHARACTER_LOWER_[i])); |
| } |
| } |
| |
| public void TestFolding() |
| { |
| // test simple case folding |
| for (int i = 0; i < FOLDING_SIMPLE_.length; i += 3) { |
| if (UCharacter.foldCase(FOLDING_SIMPLE_[i], true) != |
| FOLDING_SIMPLE_[i + 1]) { |
| errln("FAIL: foldCase(\\u" + hex(FOLDING_SIMPLE_[i]) + |
| ", true) should be \\u" + hex(FOLDING_SIMPLE_[i + 1])); |
| } |
| if (UCharacter.foldCase(FOLDING_SIMPLE_[i], false) != |
| FOLDING_SIMPLE_[i + 2]) { |
| errln("FAIL: foldCase(\\u" + hex(FOLDING_SIMPLE_[i]) + |
| ", false) should be \\u" + hex(FOLDING_SIMPLE_[i + 2])); |
| } |
| } |
| |
| // Test full string case folding with default option and separate |
| // buffers |
| if (!FOLDING_DEFAULT_[0].equals(UCharacter.foldCase(FOLDING_MIXED_[0], |
| true))) { |
| errln("FAIL: foldCase(" + hex(FOLDING_MIXED_[0]) + |
| ", true) should be " + FOLDING_DEFAULT_[0]); |
| } |
| |
| if (!FOLDING_EXCLUDE_SPECIAL_I_[0].equals( |
| UCharacter.foldCase(FOLDING_MIXED_[0], false))) { |
| errln("FAIL: foldCase(" + hex(FOLDING_MIXED_[0]) + |
| ", false) should be " + FOLDING_EXCLUDE_SPECIAL_I_[0]); |
| } |
| |
| if (!FOLDING_DEFAULT_[1].equals(UCharacter.foldCase(FOLDING_MIXED_[1], |
| true))) { |
| errln("FAIL: foldCase(" + hex(FOLDING_MIXED_[1]) + |
| ", true) should be " + hex(FOLDING_DEFAULT_[1])); |
| } |
| |
| |
| // alternate handling for dotted I/dotless i (U+0130, U+0131) |
| if (!FOLDING_EXCLUDE_SPECIAL_I_[1].equals( |
| UCharacter.foldCase(FOLDING_MIXED_[1], false))) { |
| errln("FAIL: foldCase(" + hex(FOLDING_MIXED_[1]) + |
| ", false) should be " + hex(FOLDING_EXCLUDE_SPECIAL_I_[1])); |
| } |
| } |
| |
| /** |
| * Testing the strings case mapping methods |
| */ |
| public void TestUpper() |
| { |
| // uppercase with root locale and in the same buffer |
| if (!UPPER_ROOT_.equals(UCharacter.toUpperCase(UPPER_BEFORE_))) { |
| errln("Fail " + UPPER_BEFORE_ + " after uppercase should be " + |
| UPPER_ROOT_ + " instead got " + |
| UCharacter.toUpperCase(UPPER_BEFORE_)); |
| } |
| |
| // uppercase with turkish locale and separate buffers |
| if (!UPPER_TURKISH_.equals(UCharacter.toUpperCase(TURKISH_LOCALE_, |
| UPPER_BEFORE_))) { |
| errln("Fail " + UPPER_BEFORE_ + |
| " after turkish-sensitive uppercase should be " + |
| UPPER_TURKISH_ + " instead of " + |
| UCharacter.toUpperCase(TURKISH_LOCALE_, UPPER_BEFORE_)); |
| } |
| |
| // uppercase a short string with root locale |
| if (!UPPER_MINI_UPPER_.equals(UCharacter.toUpperCase(UPPER_MINI_))) { |
| errln("error in toUpper(root locale)=\"" + UPPER_MINI_ + |
| "\" expected \"" + UPPER_MINI_UPPER_ + "\""); |
| } |
| |
| if (!SHARED_UPPERCASE_TOPKAP_.equals( |
| UCharacter.toUpperCase(SHARED_LOWERCASE_TOPKAP_))) { |
| errln("toUpper failed: expected \"" + |
| SHARED_UPPERCASE_TOPKAP_ + "\", got \"" + |
| UCharacter.toUpperCase(SHARED_LOWERCASE_TOPKAP_) + "\"."); |
| } |
| |
| if (!SHARED_UPPERCASE_TURKISH_.equals( |
| UCharacter.toUpperCase(TURKISH_LOCALE_, |
| SHARED_LOWERCASE_TOPKAP_))) { |
| errln("toUpper failed: expected \"" + |
| SHARED_UPPERCASE_TURKISH_ + "\", got \"" + |
| UCharacter.toUpperCase(TURKISH_LOCALE_, |
| SHARED_LOWERCASE_TOPKAP_) + "\"."); |
| } |
| |
| if (!SHARED_UPPERCASE_GERMAN_.equals( |
| UCharacter.toUpperCase(GERMAN_LOCALE_, |
| SHARED_LOWERCASE_GERMAN_))) { |
| errln("toUpper failed: expected \"" + SHARED_UPPERCASE_GERMAN_ |
| + "\", got \"" + UCharacter.toUpperCase(GERMAN_LOCALE_, |
| SHARED_LOWERCASE_GERMAN_) + "\"."); |
| } |
| |
| if (!SHARED_UPPERCASE_GREEK_.equals( |
| UCharacter.toUpperCase(SHARED_LOWERCASE_GREEK_))) { |
| errln("toLower failed: expected \"" + SHARED_UPPERCASE_GREEK_ + |
| "\", got \"" + UCharacter.toUpperCase( |
| SHARED_LOWERCASE_GREEK_) + "\"."); |
| } |
| } |
| |
| public void TestLower() |
| { |
| if (!LOWER_ROOT_.equals(UCharacter.toLowerCase(LOWER_BEFORE_))) { |
| errln("Fail " + LOWER_BEFORE_ + " after lowercase should be " + |
| LOWER_ROOT_ + " instead of " + |
| UCharacter.toLowerCase(LOWER_BEFORE_)); |
| } |
| |
| // lowercase with turkish locale |
| if (!LOWER_TURKISH_.equals(UCharacter.toLowerCase(TURKISH_LOCALE_, |
| LOWER_BEFORE_))) { |
| errln("Fail " + LOWER_BEFORE_ + |
| " after turkish-sensitive lowercase should be " + |
| LOWER_TURKISH_ + " instead of " + |
| UCharacter.toLowerCase(TURKISH_LOCALE_, LOWER_BEFORE_)); |
| } |
| if (!SHARED_LOWERCASE_ISTANBUL_.equals( |
| UCharacter.toLowerCase(SHARED_UPPERCASE_ISTANBUL_))) { |
| errln("1. toLower failed: expected \"" + |
| SHARED_LOWERCASE_ISTANBUL_ + "\", got \"" + |
| UCharacter.toLowerCase(SHARED_UPPERCASE_ISTANBUL_) + "\"."); |
| } |
| |
| if (!SHARED_LOWERCASE_TURKISH_.equals( |
| UCharacter.toLowerCase(TURKISH_LOCALE_, |
| SHARED_UPPERCASE_ISTANBUL_))) { |
| errln("2. toLower failed: expected \"" + |
| SHARED_LOWERCASE_TURKISH_ + "\", got \"" + |
| UCharacter.toLowerCase(TURKISH_LOCALE_, |
| SHARED_UPPERCASE_ISTANBUL_) + "\"."); |
| } |
| if (!SHARED_LOWERCASE_GREEK_.equals( |
| UCharacter.toLowerCase(GREEK_LOCALE_, |
| SHARED_UPPERCASE_GREEK_))) { |
| errln("toLower failed: expected \"" + SHARED_LOWERCASE_GREEK_ + |
| "\", got \"" + UCharacter.toLowerCase(GREEK_LOCALE_, |
| SHARED_UPPERCASE_GREEK_) + "\"."); |
| } |
| } |
| |
| public void TestTitle() |
| { |
| for (int i = 0; i < TITLE_BREAKITERATORS_.length; i ++) { |
| String test = TITLE_DATA_[i << 1]; |
| String expected = TITLE_DATA_[(i << 1) + 1]; |
| if (!expected.equals( |
| UCharacter.toTitleCase(test, |
| TITLE_BREAKITERATORS_[i]))) { |
| errln("error: titlecasing for " + hex(test) + " should be " + |
| hex(expected) + " but got " + |
| hex(UCharacter.toTitleCase(test, |
| TITLE_BREAKITERATORS_[i]))); |
| } |
| } |
| } |
| |
| public void TestSpecial() |
| { |
| for (int i = 0; i < SPECIAL_LOCALES_.length; i ++) { |
| int j = i * 3; |
| Locale locale = SPECIAL_LOCALES_[i]; |
| String str = SPECIAL_DATA_[j]; |
| if (locale != null) { |
| if (!SPECIAL_DATA_[j + 1].equals( |
| UCharacter.toLowerCase(locale, str))) { |
| errln("error lowercasing special characters " + |
| hex(str) + " expected " + hex(SPECIAL_DATA_[j + 1]) |
| + " for locale " + locale.toString() + " but got " + |
| hex(UCharacter.toLowerCase(locale, str))); |
| } |
| if (!SPECIAL_DATA_[j + 2].equals( |
| UCharacter.toUpperCase(locale, str))) { |
| errln("error uppercasing special characters " + |
| hex(str) + " expected " + SPECIAL_DATA_[j + 2] |
| + " for locale " + locale.toString() + " but got " + |
| hex(UCharacter.toUpperCase(locale, str))); |
| } |
| } |
| else { |
| if (!SPECIAL_DATA_[j + 1].equals( |
| UCharacter.toLowerCase(str))) { |
| errln("error lowercasing special characters " + |
| hex(str) + " expected " + SPECIAL_DATA_[j + 1] + |
| " but got " + |
| hex(UCharacter.toLowerCase(locale, str))); |
| } |
| if (!SPECIAL_DATA_[j + 2].equals( |
| UCharacter.toUpperCase(locale, str))) { |
| errln("error uppercasing special characters " + |
| hex(str) + " expected " + SPECIAL_DATA_[j + 2] + |
| " but got " + |
| hex(UCharacter.toUpperCase(locale, str))); |
| } |
| } |
| } |
| |
| // turkish & azerbaijani dotless i & dotted I |
| // remove dot above if there was a capital I before and there are no |
| // more accents above |
| if (!SPECIAL_DOTTED_LOWER_TURKISH_.equals(UCharacter.toLowerCase( |
| TURKISH_LOCALE_, SPECIAL_DOTTED_))) { |
| errln("error in dots.toLower(tr)=\"" + SPECIAL_DOTTED_ + |
| "\" expected \"" + SPECIAL_DOTTED_LOWER_TURKISH_ + |
| "\" but got " + UCharacter.toLowerCase(TURKISH_LOCALE_, |
| SPECIAL_DOTTED_)); |
| } |
| if (!SPECIAL_DOTTED_LOWER_GERMAN_.equals(UCharacter.toLowerCase( |
| GERMAN_LOCALE_, SPECIAL_DOTTED_))) { |
| errln("error in dots.toLower(de)=\"" + SPECIAL_DOTTED_ + |
| "\" expected \"" + SPECIAL_DOTTED_LOWER_GERMAN_ + |
| "\" but got " + UCharacter.toLowerCase(GERMAN_LOCALE_, |
| SPECIAL_DOTTED_)); |
| } |
| |
| // lithuanian dot above in uppercasing |
| if (!SPECIAL_DOT_ABOVE_UPPER_LITHUANIAN_.equals( |
| UCharacter.toUpperCase(LITHUANIAN_LOCALE_, SPECIAL_DOT_ABOVE_))) { |
| errln("error in dots.toUpper(lt)=\"" + SPECIAL_DOT_ABOVE_ + |
| "\" expected \"" + SPECIAL_DOT_ABOVE_UPPER_LITHUANIAN_ + |
| "\" but got " + UCharacter.toUpperCase(LITHUANIAN_LOCALE_, |
| SPECIAL_DOT_ABOVE_)); |
| } |
| if (!SPECIAL_DOT_ABOVE_UPPER_GERMAN_.equals(UCharacter.toUpperCase( |
| GERMAN_LOCALE_, SPECIAL_DOT_ABOVE_))) { |
| errln("error in dots.toUpper(de)=\"" + SPECIAL_DOT_ABOVE_ + |
| "\" expected \"" + SPECIAL_DOT_ABOVE_UPPER_GERMAN_ + |
| "\" but got " + UCharacter.toUpperCase(GERMAN_LOCALE_, |
| SPECIAL_DOT_ABOVE_)); |
| } |
| |
| // lithuanian adds dot above to i in lowercasing if there are more |
| // above accents |
| if (!SPECIAL_DOT_ABOVE_LOWER_LITHUANIAN_.equals( |
| UCharacter.toLowerCase(LITHUANIAN_LOCALE_, |
| SPECIAL_DOT_ABOVE_UPPER_))) { |
| errln("error in dots.toLower(lt)=\"" + SPECIAL_DOT_ABOVE_UPPER_ + |
| "\" expected \"" + SPECIAL_DOT_ABOVE_LOWER_LITHUANIAN_ + |
| "\" but got " + UCharacter.toLowerCase(LITHUANIAN_LOCALE_, |
| SPECIAL_DOT_ABOVE_UPPER_)); |
| } |
| if (!SPECIAL_DOT_ABOVE_LOWER_GERMAN_.equals( |
| UCharacter.toLowerCase(GERMAN_LOCALE_, |
| SPECIAL_DOT_ABOVE_UPPER_))) { |
| errln("error in dots.toLower(de)=\"" + SPECIAL_DOT_ABOVE_UPPER_ + |
| "\" expected \"" + SPECIAL_DOT_ABOVE_LOWER_GERMAN_ + |
| "\" but got " + UCharacter.toLowerCase(GERMAN_LOCALE_, |
| SPECIAL_DOT_ABOVE_UPPER_)); |
| } |
| } |
| |
| /** |
| * Tests for case mapping in the file SpecialCasing.txt |
| * This method reads in SpecialCasing.txt file for testing purposes. |
| * A default path is provided relative to the src path, however the user |
| * could set a system property to change the directory path.<br> |
| * e.g. java -DUnicodeData="data_dir_path" com.ibm.dev.test.lang.UCharacterTest |
| */ |
| public void TestSpecialCasingTxt() |
| { |
| try |
| { |
| // reading in the SpecialCasing file |
| BufferedReader input = TestUtil.getDataReader( |
| "unicode/SpecialCasing.txt"); |
| while (true) |
| { |
| String s = input.readLine(); |
| if (s == null) { |
| break; |
| } |
| if (s.length() == 0 || s.charAt(0) == '#') { |
| continue; |
| } |
| |
| String chstr[] = getUnicodeStrings(s); |
| StringBuffer strbuffer = new StringBuffer(chstr[0]); |
| StringBuffer lowerbuffer = new StringBuffer(chstr[1]); |
| StringBuffer upperbuffer = new StringBuffer(chstr[3]); |
| Locale locale = null; |
| for (int i = 4; i < chstr.length; i ++) { |
| String condition = chstr[i]; |
| if (Character.isLowerCase(chstr[i].charAt(0))) { |
| // specified locale |
| locale = new Locale(chstr[i], ""); |
| } |
| else if (condition.compareToIgnoreCase("Not_Before_Dot") |
| == 0) { |
| // turns I into dotless i |
| } |
| else if (condition.compareToIgnoreCase( |
| "More_Above") == 0) { |
| strbuffer.append((char)0x300); |
| lowerbuffer.append((char)0x300); |
| upperbuffer.append((char)0x300); |
| } |
| else if (condition.compareToIgnoreCase( |
| "After_Soft_Dotted") == 0) { |
| strbuffer.insert(0, 'i'); |
| lowerbuffer.insert(0, 'i'); |
| String lang = ""; |
| if (locale != null) { |
| lang = locale.getLanguage(); |
| } |
| if (lang.equals("tr") || lang.equals("az")) { |
| upperbuffer.insert(0, '\u0130'); |
| } |
| else { |
| upperbuffer.insert(0, 'I'); |
| } |
| } |
| else if (condition.compareToIgnoreCase( |
| "Final_Sigma") == 0) { |
| strbuffer.insert(0, 'c'); |
| lowerbuffer.insert(0, 'c'); |
| upperbuffer.insert(0, 'C'); |
| } |
| } |
| chstr[0] = strbuffer.toString(); |
| chstr[1] = lowerbuffer.toString(); |
| chstr[3] = upperbuffer.toString(); |
| if (locale == null) { |
| if (!UCharacter.toLowerCase(chstr[0]).equals(chstr[1])) { |
| errln(s); |
| errln("Fail: toLowerCase for character " + |
| Utility.escape(chstr[0]) + ", expected " |
| + Utility.escape(chstr[1]) + " but resulted in " + |
| Utility.escape(UCharacter.toLowerCase(chstr[0]))); |
| } |
| if (!UCharacter.toUpperCase(chstr[0]).equals(chstr[3])) { |
| errln(s); |
| errln("Fail: toUpperCase for character " + |
| Utility.escape(chstr[0]) + ", expected " |
| + Utility.escape(chstr[3]) + " but resulted in " + |
| Utility.escape(UCharacter.toUpperCase(chstr[0]))); |
| } |
| } |
| else { |
| if (!UCharacter.toLowerCase(locale, chstr[0]).equals( |
| chstr[1])) { |
| errln(s); |
| errln("Fail: toLowerCase for character " + |
| Utility.escape(chstr[0]) + ", expected " |
| + Utility.escape(chstr[1]) + " but resulted in " + |
| Utility.escape(UCharacter.toLowerCase(locale, |
| chstr[0]))); |
| } |
| if (!UCharacter.toUpperCase(locale, chstr[0]).equals( |
| chstr[3])) { |
| errln(s); |
| errln("Fail: toUpperCase for character " + |
| Utility.escape(chstr[0]) + ", expected " |
| + Utility.escape(chstr[3]) + " but resulted in " + |
| Utility.escape(UCharacter.toUpperCase(locale, |
| chstr[0]))); |
| } |
| } |
| } |
| input.close(); |
| } |
| catch (Exception e) |
| { |
| e.printStackTrace(); |
| } |
| } |
| |
| public void TestUpperLower() |
| { |
| int upper[] = {0x0041, 0x0042, 0x00b2, 0x01c4, 0x01c6, 0x01c9, 0x01c8, |
| 0x01c9, 0x000c}; |
| int lower[] = {0x0061, 0x0062, 0x00b2, 0x01c6, 0x01c6, 0x01c9, 0x01c9, |
| 0x01c9, 0x000c}; |
| String upperTest = "abcdefg123hij.?:klmno"; |
| String lowerTest = "ABCDEFG123HIJ.?:KLMNO"; |
| |
| // Checks LetterLike Symbols which were previously a source of |
| // confusion [Bertrand A. D. 02/04/98] |
| for (int i = 0x2100; i < 0x2138; i ++) { |
| if (i != 0x2126 && i != 0x212a && i != 0x212b) { |
| if (i != UCharacter.toLowerCase(i)) { // itself |
| errln("Failed case conversion with itself: \\u" |
| + Utility.hex(i, 4)); |
| } |
| if (i != UCharacter.toUpperCase(i)) { |
| errln("Failed case conversion with itself: \\u" |
| + Utility.hex(i, 4)); |
| } |
| } |
| } |
| for (int i = 0; i < upper.length; i ++) { |
| if (UCharacter.toLowerCase(upper[i]) != lower[i]) { |
| errln("FAILED UCharacter.tolower() for \\u" |
| + Utility.hex(upper[i], 4) |
| + " Expected \\u" + Utility.hex(lower[i], 4) |
| + " Got \\u" |
| + Utility.hex(UCharacter.toLowerCase(upper[i]), 4)); |
| } |
| } |
| logln("testing upper lower"); |
| for (int i = 0; i < upperTest.length(); i ++) { |
| logln("testing to upper to lower"); |
| if (UCharacter.isLetter(upperTest.charAt(i)) && |
| !UCharacter.isLowerCase(upperTest.charAt(i))) { |
| errln("Failed isLowerCase test at \\u" |
| + Utility.hex(upperTest.charAt(i), 4)); |
| } |
| else if (UCharacter.isLetter(lowerTest.charAt(i)) |
| && !UCharacter.isUpperCase(lowerTest.charAt(i))) { |
| errln("Failed isUpperCase test at \\u" |
| + Utility.hex(lowerTest.charAt(i), 4)); |
| } |
| else if (upperTest.charAt(i) |
| != UCharacter.toLowerCase(lowerTest.charAt(i))) { |
| errln("Failed case conversion from \\u" |
| + Utility.hex(lowerTest.charAt(i), 4) + " To \\u" |
| + Utility.hex(upperTest.charAt(i), 4)); |
| } |
| else if (lowerTest.charAt(i) |
| != UCharacter.toUpperCase(upperTest.charAt(i))) { |
| errln("Failed case conversion : \\u" |
| + Utility.hex(upperTest.charAt(i), 4) + " To \\u" |
| + Utility.hex(lowerTest.charAt(i), 4)); |
| } |
| else if (upperTest.charAt(i) |
| != UCharacter.toLowerCase(upperTest.charAt(i))) { |
| errln("Failed case conversion with itself: \\u" |
| + Utility.hex(upperTest.charAt(i))); |
| } |
| else if (lowerTest.charAt(i) |
| != UCharacter.toUpperCase(lowerTest.charAt(i))) { |
| errln("Failed case conversion with itself: \\u" |
| + Utility.hex(lowerTest.charAt(i))); |
| } |
| } |
| logln("done testing upper Lower"); |
| } |
| |
| // private data members - test data -------------------------------------- |
| |
| private static final Locale TURKISH_LOCALE_ = new Locale("tr", "TR"); |
| private static final Locale GERMAN_LOCALE_ = new Locale("de", "DE"); |
| private static final Locale GREEK_LOCALE_ = new Locale("el", "GR"); |
| private static final Locale ENGLISH_LOCALE_ = new Locale("en", "US"); |
| private static final Locale LITHUANIAN_LOCALE_ = new Locale("lt", "LT"); |
| |
| private static final BreakIterator BREAKITERATOR_CHARACTER_ = |
| BreakIterator.getCharacterInstance(); |
| private static final BreakIterator BREAKITERATOR_WORD_ = |
| BreakIterator.getWordInstance(); |
| private static final BreakIterator BREAKITERATOR_TITLE_ = |
| BreakIterator.getTitleInstance(); |
| |
| private static final int CHARACTER_UPPER_[] = |
| {0x41, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, |
| 0x00b1, 0x00b2, 0xb3, 0x0048, 0x0049, 0x004a, 0x002e, |
| 0x003f, 0x003a, 0x004b, 0x004c, 0x4d, 0x004e, 0x004f, |
| 0x01c4, 0x01c8, 0x000c, 0x0000}; |
| private static final int CHARACTER_LOWER_[] = |
| {0x61, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, |
| 0x00b1, 0x00b2, 0xb3, 0x0068, 0x0069, 0x006a, 0x002e, |
| 0x003f, 0x003a, 0x006b, 0x006c, 0x6d, 0x006e, 0x006f, |
| 0x01c6, 0x01c9, 0x000c, 0x0000}; |
| |
| private static final int FOLDING_SIMPLE_[] = { |
| // input, default, exclude special i |
| 0x61, 0x61, 0x61, |
| 0x49, 0x69, 0x131, |
| 0x130, 0x69, 0x69, |
| 0x131, 0x131, 0x131, |
| 0xdf, 0xdf, 0xdf, |
| 0xfb03, 0xfb03, 0xfb03, |
| 0x1040e,0x10436,0x10436, |
| 0x5ffff,0x5ffff,0x5ffff |
| }; |
| private static final String FOLDING_MIXED_[] = |
| {"\u0061\u0042\u0130\u0049\u0131\u03d0\u00df\ufb03\ud93f\udfff", |
| "A\u00df\u00b5\ufb03\uD801\uDC0C\u0130\u0131"}; |
| private static final String FOLDING_DEFAULT_[] = |
| {"\u0061\u0062\u0069\u0307\u0069\u0131\u03b2\u0073\u0073\u0066\u0066\u0069\ud93f\udfff", |
| "ass\u03bcffi\uD801\uDC34i\u0307\u0131"}; |
| private static final String FOLDING_EXCLUDE_SPECIAL_I_[] = |
| {"\u0061\u0062\u0069\u0131\u0131\u03b2\u0073\u0073\u0066\u0066\u0069\ud93f\udfff", |
| "ass\u03bcffi\uD801\uDC34i\u0131"}; |
| /** |
| * "IESUS CHRISTOS" |
| */ |
| private static final String SHARED_UPPERCASE_GREEK_ = |
| "\u0399\u0395\u03a3\u03a5\u03a3\u0020\u03a7\u03a1\u0399\u03a3\u03a4\u039f\u03a3"; |
| /** |
| * "iesus christos" |
| */ |
| private static final String SHARED_LOWERCASE_GREEK_ = |
| "\u03b9\u03b5\u03c3\u03c5\u03c2\u0020\u03c7\u03c1\u03b9\u03c3\u03c4\u03bf\u03c2"; |
| private static final String SHARED_LOWERCASE_TURKISH_ = |
| "\u0069\u0073\u0074\u0061\u006e\u0062\u0075\u006c\u002c\u0020\u006e\u006f\u0074\u0020\u0063\u006f\u006e\u0073\u0074\u0061\u006e\u0074\u0131\u006e\u006f\u0070\u006c\u0065\u0021"; |
| private static final String SHARED_UPPERCASE_TURKISH_ = |
| "\u0054\u004f\u0050\u004b\u0041\u0050\u0049\u0020\u0050\u0041\u004c\u0041\u0043\u0045\u002c\u0020\u0130\u0053\u0054\u0041\u004e\u0042\u0055\u004c"; |
| private static final String SHARED_UPPERCASE_ISTANBUL_ = |
| "\u0130STANBUL, NOT CONSTANTINOPLE!"; |
| private static final String SHARED_LOWERCASE_ISTANBUL_ = |
| "i\u0307stanbul, not constantinople!"; |
| private static final String SHARED_LOWERCASE_TOPKAP_ = |
| "topkap\u0131 palace, istanbul"; |
| private static final String SHARED_UPPERCASE_TOPKAP_ = |
| "TOPKAPI PALACE, ISTANBUL"; |
| private static final String SHARED_LOWERCASE_GERMAN_ = |
| "S\u00FC\u00DFmayrstra\u00DFe"; |
| private static final String SHARED_UPPERCASE_GERMAN_ = |
| "S\u00DCSSMAYRSTRASSE"; |
| |
| private static final String UPPER_BEFORE_ = |
| "\u0061\u0042\u0069\u03c2\u00df\u03c3\u002f\ufb03\ufb03\ufb03\ud93f\udfff"; |
| private static final String UPPER_ROOT_ = |
| "\u0041\u0042\u0049\u03a3\u0053\u0053\u03a3\u002f\u0046\u0046\u0049\u0046\u0046\u0049\u0046\u0046\u0049\ud93f\udfff"; |
| private static final String UPPER_TURKISH_ = |
| "\u0041\u0042\u0130\u03a3\u0053\u0053\u03a3\u002f\u0046\u0046\u0049\u0046\u0046\u0049\u0046\u0046\u0049\ud93f\udfff"; |
| private static final String UPPER_MINI_ = "\u00df\u0061"; |
| private static final String UPPER_MINI_UPPER_ = "\u0053\u0053\u0041"; |
| |
| private static final String LOWER_BEFORE_ = |
| "\u0061\u0042\u0049\u03a3\u00df\u03a3\u002f\ud93f\udfff"; |
| private static final String LOWER_ROOT_ = |
| "\u0061\u0062\u0069\u03c3\u00df\u03c2\u002f\ud93f\udfff"; |
| private static final String LOWER_TURKISH_ = |
| "\u0061\u0062\u0131\u03c3\u00df\u03c2\u002f\ud93f\udfff"; |
| |
| /** |
| * each item is an array with input string, result string, locale |
| */ |
| private static final String TITLE_DATA_[] = { |
| "\u0061\u0042\u0020\u0069\u03c2\u0020\u00df\u03c3\u002f\ufb03\ud93f\udfff", |
| "\u0041\u0042\u0020\u0049\u03a3\u0020\u0053\u0073\u03a3\u002f\u0046\u0066\u0069\ud93f\udfff", |
| |
| "\u0061\u0042\u0020\u0069\u03c2\u0020\u00df\u03c3\u002f\ufb03\ud93f\udfff", |
| "\u0041\u0062\u0020\u0049\u03c2\u0020\u0053\u0073\u03c3\u002f\u0046\u0066\u0069\ud93f\udfff", |
| |
| " tHe QUIcK bRoWn", " The Quick Brown", |
| |
| "\u01c4\u01c5\u01c6\u01c7\u01c8\u01c9\u01ca\u01cb\u01cc", |
| "\u01c5\u01c5\u01c5\u01c8\u01c8\u01c8\u01cb\u01cb\u01cb", // UBRK_CHARACTER |
| |
| "\u01c9ubav ljubav", "\u01c8ubav Ljubav", // Lj vs. L+j |
| |
| "'oH dOn'T tItLeCaSe AfTeR lEtTeR+'", |
| "'Oh Don't Titlecase After Letter+'" |
| }; |
| |
| private static final BreakIterator TITLE_BREAKITERATORS_[] = |
| { |
| BREAKITERATOR_CHARACTER_, |
| BREAKITERATOR_WORD_, |
| BREAKITERATOR_TITLE_, |
| BREAKITERATOR_CHARACTER_, |
| null, |
| null |
| }; |
| |
| /** |
| * <p>basic string, lower string, upper string, title string</p> |
| */ |
| private static final String SPECIAL_DATA_[] = { |
| UTF16.valueOf(0x1043C) + UTF16.valueOf(0x10414), |
| UTF16.valueOf(0x1043C) + UTF16.valueOf(0x1043C), |
| UTF16.valueOf(0x10414) + UTF16.valueOf(0x10414), |
| "ab'cD \uFB00i\u0131I\u0130 \u01C7\u01C8\u01C9 " + |
| UTF16.valueOf(0x1043C) + UTF16.valueOf(0x10414), |
| "ab'cd \uFB00i\u0131ii\u0307 \u01C9\u01C9\u01C9 " + |
| UTF16.valueOf(0x1043C) + UTF16.valueOf(0x1043C), |
| "AB'CD FFIII\u0130 \u01C7\u01C7\u01C7 " + |
| UTF16.valueOf(0x10414) + UTF16.valueOf(0x10414), |
| // sigmas followed/preceded by cased letters |
| "i\u0307\u03a3\u0308j \u0307\u03a3\u0308j i\u00ad\u03a3\u0308 \u0307\u03a3\u0308 ", |
| "i\u0307\u03c3\u0308j \u0307\u03c3\u0308j i\u00ad\u03c2\u0308 \u0307\u03c3\u0308 ", |
| "I\u0307\u03a3\u0308J \u0307\u03a3\u0308J I\u00ad\u03a3\u0308 \u0307\u03a3\u0308 " |
| }; |
| private static final Locale SPECIAL_LOCALES_[] = { |
| null, |
| ENGLISH_LOCALE_, |
| null, |
| }; |
| |
| private static final String SPECIAL_DOTTED_ = |
| "I \u0130 I\u0307 I\u0327\u0307 I\u0301\u0307 I\u0327\u0307\u0301"; |
| private static final String SPECIAL_DOTTED_LOWER_TURKISH_ = |
| "\u0131 i i\u0307 i\u0327\u0307 \u0131\u0301\u0307 i\u0327\u0307\u0301"; |
| private static final String SPECIAL_DOTTED_LOWER_GERMAN_ = |
| "i i\u0307 i\u0307 i\u0327\u0307 i\u0301\u0307 i\u0327\u0307\u0301"; |
| private static final String SPECIAL_DOT_ABOVE_ = |
| "a\u0307 \u0307 i\u0307 j\u0327\u0307 j\u0301\u0307"; |
| private static final String SPECIAL_DOT_ABOVE_UPPER_LITHUANIAN_ = |
| "A\u0307 \u0307 I J\u0327 J\u0301\u0307"; |
| private static final String SPECIAL_DOT_ABOVE_UPPER_GERMAN_ = |
| "A\u0307 \u0307 I\u0307 J\u0327\u0307 J\u0301\u0307"; |
| private static final String SPECIAL_DOT_ABOVE_UPPER_ = |
| "I I\u0301 J J\u0301 \u012e \u012e\u0301 \u00cc\u00cd\u0128"; |
| private static final String SPECIAL_DOT_ABOVE_LOWER_LITHUANIAN_ = |
| "i i\u0307\u0301 j j\u0307\u0301 \u012f \u012f\u0307\u0301 i\u0307\u0300i\u0307\u0301i\u0307\u0303"; |
| private static final String SPECIAL_DOT_ABOVE_LOWER_GERMAN_ = |
| "i i\u0301 j j\u0301 \u012f \u012f\u0301 \u00ec\u00ed\u0129"; |
| |
| // private methods ------------------------------------------------------- |
| |
| /** |
| * Converting the hex numbers represented betwee n ';' to Unicode strings |
| * @param str string to break up into Unicode strings |
| * @return array of Unicode strings ending with a null |
| */ |
| private String[] getUnicodeStrings(String str) |
| { |
| Vector v = new Vector(10); |
| int start = 0; |
| for (int casecount = 4; casecount > 0; casecount --) { |
| int end = str.indexOf("; ", start); |
| String casestr = str.substring(start, end); |
| StringBuffer buffer = new StringBuffer(); |
| int spaceoffset = 0; |
| while (spaceoffset < casestr.length()) { |
| int nextspace = casestr.indexOf(' ', spaceoffset); |
| if (nextspace == -1) { |
| nextspace = casestr.length(); |
| } |
| buffer.append((char)Integer.parseInt( |
| casestr.substring(spaceoffset, nextspace), |
| 16)); |
| spaceoffset = nextspace + 1; |
| } |
| start = end + 2; |
| v.add(buffer.toString()); |
| } |
| int comments = str.indexOf(" #", start); |
| if (comments != -1 && comments != start) { |
| if (str.charAt(comments - 1) == ';') { |
| comments --; |
| } |
| String conditions = str.substring(start, comments); |
| int offset = 0; |
| while (offset < conditions.length()) { |
| int spaceoffset = conditions.indexOf(' ', offset); |
| if (spaceoffset == -1) { |
| spaceoffset = conditions.length(); |
| } |
| v.add(conditions.substring(offset, spaceoffset)); |
| offset = spaceoffset + 1; |
| } |
| } |
| int size = v.size(); |
| String result[] = new String[size]; |
| for (int i = 0; i < size; i ++) { |
| result[i] = (String)v.elementAt(i); |
| } |
| return result; |
| } |
| } |
| |
