| /** |
| ******************************************************************************* |
| * Copyright (C) 1996-2001, International Business Machines Corporation and * |
| * others. All Rights Reserved. * |
| ******************************************************************************* |
| * |
| * $Source: /xsrl/Nsvn/icu/icu4j/src/com/ibm/icu/test/text/Attic/UCharacterTest.java,v $ |
| * $Date: 2001/03/23 19:52:03 $ |
| * $Revision: 1.9 $ |
| * |
| ******************************************************************************* |
| */ |
| |
| package com.ibm.icu.test.text; |
| |
| import java.io.BufferedReader; |
| import java.io.FileReader; |
| import java.io.FileNotFoundException; |
| import java.util.Locale; |
| import com.ibm.test.TestFmwk; |
| import com.ibm.text.UCharacter; |
| import com.ibm.text.UCharacterCategory; |
| import com.ibm.text.UCharacterDirection; |
| import com.ibm.text.UTF16; |
| |
| /** |
| * Testing class for UCharacter |
| * Mostly following the test cases for ICU |
| * @author Syn Wee Quek |
| * @since nov 04 2000 |
| */ |
| public final class UCharacterTest extends TestFmwk |
| { |
| // private variables ============================================= |
| |
| /** |
| * ICU4J data version number |
| */ |
| private final String VERSION_ = "3.0.0.0"; |
| |
| // constructor =================================================== |
| |
| /** |
| * Constructor |
| */ |
| public UCharacterTest() |
| { |
| } |
| |
| // public methods ================================================ |
| |
| /** |
| * Testing the uppercase and lowercase function of UCharacter |
| */ |
| public void TestUpperLower() |
| { |
| // variables to test the uppercase and lowercase characters |
| int upper[] = {0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0xb1, 0xb2, |
| 0xb3, 0x48, 0x49, 0x4a, 0x2e, 0x3f, 0x3a, 0x4b, 0x4c, |
| 0x4d, 0x4e, 0x4f, 0x01c4, 0x01c8, 0x000c, 0x0000}; |
| int lower[] = {0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0xb1, 0x00b2, |
| 0xb3, 0x68, 0x69, 0x6a, 0x2e, 0x3f, 0x3a, 0x6b, 0x6c, |
| 0x6d, 0x6e, 0x6f, 0x01c6, 0x01c9, 0x000c, 0x0000}; |
| |
| int size = upper.length; |
| |
| for (int i = 0; i < size; i ++) |
| { |
| if (UCharacter.isLetter(lower[i]) && !UCharacter.isLowerCase(lower[i])) |
| { |
| errln("FAIL isLowerCase test for 0x" + |
| Integer.toHexString(lower[i])); |
| break; |
| } |
| if (UCharacter.isLetter(upper[i]) && !(UCharacter.isUpperCase(upper[i]) |
| || UCharacter.isTitleCase(upper[i]))) |
| { |
| errln("FAIL isUpperCase test for 0x" + |
| Integer.toHexString(upper[i])); |
| break; |
| } |
| if (lower[i] != UCharacter.toLowerCase(upper[i]) || |
| (upper[i] != UCharacter.toUpperCase(lower[i]) && |
| upper[i] != UCharacter.toTitleCase(lower[i]))) |
| { |
| errln("FAIL case conversion test for 0x" + |
| Integer.toHexString(upper[i]) + " to 0x" + |
| Integer.toHexString(lower[i])); |
| break; |
| } |
| if (lower[i] != UCharacter.toLowerCase(lower[i])) |
| { |
| errln("FAIL lower case conversion test for 0x" + |
| Integer.toHexString(lower[i])); |
| break; |
| } |
| if (upper[i] != UCharacter.toUpperCase(upper[i]) && |
| upper[i] != UCharacter.toTitleCase(upper[i])) |
| { |
| errln("FAIL upper case conversion test for 0x" + |
| Integer.toHexString(upper[i])); |
| break; |
| } |
| logln("Ok 0x" + Integer.toHexString(upper[i]) + " and 0x" + |
| Integer.toHexString(lower[i])); |
| } |
| } |
| |
| /** |
| * Testing the letter and number determination in UCharacter |
| */ |
| public void TestLetterNumber() |
| { |
| for (int i = 0x0041; i < 0x005B; i ++) |
| if (!UCharacter.isLetter(i)) |
| errln("FAIL 0x" + Integer.toHexString(i) + " expected to be a letter"); |
| |
| for (int i = 0x0660; i < 0x066A; i ++) |
| if (UCharacter.isLetter(i)) |
| errln("FAIL 0x" + Integer.toHexString(i) + |
| " expected not to be a letter"); |
| |
| for (int i = 0x0660; i < 0x066A; i ++) |
| if (!UCharacter.isDigit(i)) |
| errln("FAIL 0x" + Integer.toHexString(i) + " expected to be a digit"); |
| |
| for (int i = 0x0041; i < 0x005B; i ++) |
| if (!UCharacter.isLetterOrDigit(i)) |
| errln("FAIL 0x" + Integer.toHexString(i) + |
| " expected not to be a digit"); |
| |
| for (int i = 0x0660; i < 0x066A; i ++) |
| if (!UCharacter.isLetterOrDigit(i)) |
| errln("FAIL 0x" + Integer.toHexString(i) + |
| "expected to be either a letter or a digit"); |
| } |
| |
| /** |
| * Tests for space determination in UCharacter |
| */ |
| public void TestSpaces() |
| { |
| int spaces[] = {0x0020, 0x00a0, 0x2000, 0x2001, 0x2005}; |
| int nonspaces[] = {0x61, 0x62, 0x63, 0x64, 0x74}; |
| int whitespaces[] = {0x2008, 0x2009, 0x200a, 0x001c, 0x000c}; |
| int nonwhitespaces[] = {0x61, 0x62, 0x3c, 0x28, 0x3f}; |
| |
| int size = spaces.length; |
| for (int i = 0; i < size; i ++) |
| { |
| if (!UCharacter.isSpaceChar(spaces[i])) |
| { |
| errln("FAIL 0x" + Integer.toHexString(spaces[i]) + |
| " expected to be a space character"); |
| break; |
| } |
| |
| if (UCharacter.isSpaceChar(nonspaces[i])) |
| { |
| errln("FAIL 0x" + Integer.toHexString(nonspaces[i]) + |
| " expected not to be space character"); |
| break; |
| } |
| |
| if (!UCharacter.isWhitespace(whitespaces[i])) |
| { |
| errln("FAIL 0x" + Integer.toHexString(whitespaces[i]) + |
| " expected to be a white space character"); |
| break; |
| } |
| if (UCharacter.isWhitespace(nonwhitespaces[i])) |
| { |
| errln("FAIL 0x" + Integer.toHexString(nonwhitespaces[i]) + |
| " expected not to be a space character"); |
| break; |
| } |
| logln("Ok 0x" + Integer.toHexString(spaces[i]) + " and 0x" + |
| Integer.toHexString(nonspaces[i]) + " and 0x" + |
| Integer.toHexString(whitespaces[i]) + " and 0x" + |
| Integer.toHexString(nonwhitespaces[i])); |
| } |
| } |
| |
| /** |
| * Tests for defined and undefined characters |
| */ |
| public void TestDefined() |
| { |
| int undefined[] = {0xfff1, 0xfff7, 0xfa30}; |
| int defined[] = {0x523E, 0x4f88, 0xfffd}; |
| |
| int size = undefined.length; |
| for (int i = 0; i < size; i ++) |
| { |
| if (UCharacter.isDefined(undefined[i])) |
| { |
| errln("FAIL 0x" + Integer.toHexString(undefined[i]) + |
| " expected not to be defined"); |
| break; |
| } |
| if (!UCharacter.isDefined(defined[i])) |
| { |
| errln("FAIL 0x" + Integer.toHexString(defined[i]) + |
| " expected defined"); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * Tests for base characters and their cellwidth |
| */ |
| public void TestBase() |
| { |
| int base[] = {0x0061, 0x0031, 0x03d2}; |
| int nonbase[] = {0x002B, 0x0020, 0x203B}; |
| int size = base.length; |
| for (int i = 0; i < size; i ++) |
| { |
| if (UCharacter.isBaseForm(nonbase[i])) |
| { |
| errln("FAIL 0x" + Integer.toHexString(nonbase[i]) + |
| " expected not to be a base character"); |
| break; |
| } |
| if (!UCharacter.isBaseForm(base[i])) |
| { |
| errln("FAIL 0x" + Integer.toHexString(base[i]) + |
| " expected to be a base character"); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * Tests for digit characters |
| */ |
| public void TestDigits() |
| { |
| int digits[] = {0x0030, 0x0662, 0x0F23, 0x0ED5, 0x2160}; |
| |
| //special characters not in the properties table |
| int digits2[] = {0x3007, 0x4e00, 0x4e8c, 0x4e09, 0x56d8, 0x4e94, 0x516d, |
| 0x4e03, 0x516b, 0x4e5d}; |
| int nondigits[] = {0x0010, 0x0041, 0x0122, 0x68FE}; |
| |
| int digitvalues[] = {0, 2, 3, 5, 1}; |
| int digitvalues2[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; |
| |
| int size = digits.length; |
| for (int i = 0; i < size; i ++) |
| if (UCharacter.isDigit(digits[i]) && |
| UCharacter.digit(digits[i]) != digitvalues[i]) |
| { |
| errln("FAIL 0x" + Integer.toHexString(digits[i]) + |
| " expected digit with value " + digitvalues[i]); |
| break; |
| } |
| |
| size = nondigits.length; |
| for (int i = 0; i < size; i ++) |
| if (UCharacter.isDigit(nondigits[i])) |
| { |
| errln("FAIL 0x" + Integer.toHexString(nondigits[i]) + |
| " expected nondigit"); |
| break; |
| } |
| |
| size = digits2.length; |
| for (int i = 0; i < 10; i ++) |
| if (UCharacter.isDigit(digits2[i]) && |
| UCharacter.digit(digits2[i]) != digitvalues2[i]) |
| { |
| errln("FAIL 0x" + Integer.toHexString(digits2[i]) + |
| " expected digit with value " + digitvalues2[i]); |
| break; |
| } |
| } |
| |
| /** |
| * Tests for version |
| */ |
| public void TestVersion() |
| { |
| String version = UCharacter.getUnicodeVersion(); |
| if (!version.equals(VERSION_)) |
| errln("FAIL expected " + VERSION_); |
| } |
| |
| /** |
| * Tests for control characters |
| */ |
| /* |
| public void TestControl() |
| { |
| int control[] = {0x001b, 0x0097, 0x0082}; |
| int noncontrol[] = {0x61, 0x0031, 0x00e2}; |
| |
| int size = control.length; |
| for (int i = 0; i < size; i ++) |
| { |
| if (!UCharacter.isControl(control[i])) |
| { |
| errln("FAIL 0x" + Integer.toHexString(control[i]) + |
| " expected to be a control character"); |
| break; |
| } |
| if (UCharacter.isControl(noncontrol[i])) |
| { |
| errln("FAIL 0x" + Integer.toHexString(noncontrol[i]) + |
| " expected to be not a control character"); |
| break; |
| } |
| |
| logln("Ok 0x" + Integer.toHexString(control[i]) + " and 0x" + |
| Integer.toHexString(noncontrol[i])); |
| } |
| } |
| */ |
| |
| /** |
| * Tests for printable characters |
| */ |
| public void TestPrint() |
| { |
| int printable[] = {0x0042, 0x005f, 0x2014}; |
| int nonprintable[] = {0x200c, 0x009f, 0x001b}; |
| |
| int size = printable.length; |
| for (int i = 0; i < size; i ++) |
| { |
| if (!UCharacter.isPrintable(printable[i])) |
| { |
| errln("FAIL 0x" + Integer.toHexString(printable[i]) + |
| " expected to be a printable character"); |
| break; |
| } |
| if (UCharacter.isPrintable(nonprintable[i])) |
| { |
| errln("FAIL 0x" + Integer.toHexString(nonprintable[i]) + |
| " expected not to be a printable character"); |
| break; |
| } |
| logln("Ok 0x" + Integer.toHexString(printable[i]) + " and 0x" + |
| Integer.toHexString(nonprintable[i])); |
| } |
| |
| // test all ISO 8 controls |
| for (int ch = 0; ch <= 0x9f; ++ ch) { |
| if (ch == 0x20) { |
| // skip ASCII graphic characters and continue with DEL |
| ch = 0x7f; |
| } |
| if (UCharacter.isPrintable(ch)) { |
| errln("Fail 0x" + Integer.toHexString(ch) + |
| " is a ISO 8 control character hence not printable\n"); |
| } |
| } |
| |
| /* test all Latin-1 graphic characters */ |
| for (int ch = 0x20; ch <= 0xff; ++ ch) { |
| if (ch == 0x7f) { |
| ch = 0xa0; |
| } |
| if (!UCharacter.isPrintable(ch)) { |
| errln("Fail 0x" + Integer.toHexString(ch) + |
| " is a Latin-1 graphic character\n"); |
| } |
| } |
| } |
| |
| /** |
| * Testing for identifier characters |
| */ |
| public void TestIdentifier() |
| { |
| int unicodeidstart[] = {0x0250, 0x00e2, 0x0061}; |
| int nonunicodeidstart[] = {0x2000, 0x000a, 0x2019}; |
| int unicodeidpart[] = {0x005f, 0x0032, 0x0045}; |
| int nonunicodeidpart[] = {0x2030, 0x00a3, 0x0020}; |
| int idignore[] = {0x070F, 0x180B, 0x180C}; |
| int nonidignore[] = {0x0075, 0x00a3, 0x0061}; |
| |
| int size = unicodeidstart.length; |
| for (int i = 0; i < size; i ++) |
| { |
| if (!UCharacter.isUnicodeIdentifierStart(unicodeidstart[i])) |
| { |
| errln("FAIL 0x" + Integer.toHexString(unicodeidstart[i]) + |
| " expected to be a unicode identifier start character"); |
| break; |
| } |
| if (UCharacter.isUnicodeIdentifierStart(nonunicodeidstart[i])) |
| { |
| errln("FAIL 0x" + Integer.toHexString(nonunicodeidstart[i]) + |
| " expected not to be a unicode identifier start character"); |
| break; |
| } |
| if (!UCharacter.isUnicodeIdentifierPart(unicodeidpart[i])) |
| { |
| errln("FAIL 0x" + Integer.toHexString(unicodeidpart[i]) + |
| " expected to be a unicode identifier part character"); |
| break; |
| } |
| if (UCharacter.isUnicodeIdentifierPart(nonunicodeidpart[i])) |
| { |
| errln("FAIL 0x" + Integer.toHexString(nonunicodeidpart[i]) + |
| " expected not to be a unicode identifier part character"); |
| break; |
| } |
| if (!UCharacter.isIdentifierIgnorable(idignore[i])) |
| { |
| errln("FAIL 0x" + Integer.toHexString(idignore[i]) + |
| " expected to be a ignorable unicode character"); |
| break; |
| } |
| if (UCharacter.isIdentifierIgnorable(nonidignore[i])) |
| { |
| errln("FAIL 0x" + Integer.toHexString(nonidignore[i]) + |
| " expected not to be a ignorable unicode character"); |
| break; |
| } |
| logln("Ok 0x" + Integer.toHexString(unicodeidstart[i]) + " and 0x" + |
| Integer.toHexString(nonunicodeidstart[i]) + " and 0x" + |
| Integer.toHexString(unicodeidpart[i]) + " and 0x" + |
| Integer.toHexString(nonunicodeidpart[i]) + " and 0x" + |
| Integer.toHexString(idignore[i]) + " and 0x" + |
| Integer.toHexString(nonidignore[i])); |
| } |
| } |
| |
| /** |
| * Tests for the character types, direction.<br> |
| * This method reads in UnicodeData.txt file for testing purposes. A default |
| * path is provided relative to the class path, however if the user could |
| * set a system property to change the path.<br> |
| * e.g. java -DUnicodeData="anyfile.dat" com.ibm.test.text.UCharacterTest |
| */ |
| public void TestUnicodeData() |
| { |
| // this is the 2 char category types used in the UnicodeData file |
| final String TYPE = |
| "LuLlLtLmLoMnMeMcNdNlNoZsZlZpCcCfCoCsPdPsPePcPoSmScSkSoPiPf"; |
| |
| // directory types used in the UnicodeData file |
| // padded by spaces to make each type size 4 |
| final String DIR = |
| "L R EN ES ET AN CS B S WS ON LRE LRO AL RLE RLO PDF NSM BN "; |
| |
| // default unicode data file name |
| final String UNICODE_DATA_FILE = "src//data//unicode//UnicodeData.txt"; |
| |
| // unicode data file path system name |
| final String UNICODE_DATA_SYSTEM_NAME = "UnicodeData"; |
| String s = System.getProperty(UNICODE_DATA_SYSTEM_NAME); |
| if (s == null) |
| // assuming runtime directory is on the same level as the source |
| s = System.getProperty("user.dir") + "//..//" + UNICODE_DATA_FILE; |
| |
| final int LASTUNICODECHAR = 0xFFFD; |
| int ch = 0, |
| index = 0, |
| type = 0, |
| dir = 0; |
| |
| try |
| { |
| // reading in the UnicodeData file |
| FileReader fr = new FileReader(s); |
| BufferedReader input = new BufferedReader(fr); |
| |
| while (ch != LASTUNICODECHAR) |
| { |
| s= input.readLine(); |
| |
| // geting the unicode character, its type and its direction |
| ch = Integer.parseInt(s.substring(0, 4), 16); |
| index = s.indexOf(';', 5); |
| String t = s.substring(index + 1, index + 3); |
| index += 4; |
| byte cc = (byte)(Integer.parseInt(s.substring(index, |
| s.indexOf(';', index)))); |
| index = s.indexOf(';', index); |
| String d = s.substring(index + 1, s.indexOf(';', index + 1)); |
| |
| // testing the category |
| // we override the general category of some control characters |
| if (ch == 9 || ch == 0xb || ch == 0x1f) |
| type = UCharacterCategory.SPACE_SEPARATOR; |
| else |
| if (ch == 0xc) |
| type = UCharacterCategory.LINE_SEPARATOR; |
| else |
| if (ch == 0xa || ch == 0xd || ch == 0x1c || ch == 0x1d || |
| ch == 0x1e || ch == 0x85) |
| type = UCharacterCategory.PARAGRAPH_SEPARATOR; |
| else |
| { |
| type = TYPE.indexOf(t); |
| if (type < 0) |
| type = 0; |
| else |
| type = (type >> 1) + 1; |
| } |
| |
| if (UCharacter.getType(ch) != type) |
| { |
| errln("FAIL 0x" + Integer.toHexString(ch) + " expected type " + |
| type); |
| break; |
| } |
| |
| // testing combining class |
| if (UCharacter.getCombiningClass(ch) != cc) |
| { |
| errln("FAIL 0x" + Integer.toHexString(ch) + " expected combining " + |
| "class " + cc); |
| break; |
| } |
| |
| // testing the direction |
| if (d.length() == 1) |
| d = d + " "; |
| |
| dir = DIR.indexOf(d) >> 2; |
| if (UCharacter.getDirection(ch) != dir) |
| { |
| errln("FAIL 0x" + Integer.toHexString(ch) + |
| " expected wrong direction " + dir); |
| break; |
| } |
| } |
| input.close(); |
| } |
| catch (FileNotFoundException e) |
| { |
| errln("FAIL UnicodeData.txt not found\n" + |
| "Configure the system setting UnicodeData to the right path\n" + |
| "e.g. java -DUnicodeData=\"anyfile.dat\" " + |
| "com.ibm.icu.test.text.UCharacterTest"); |
| } |
| catch (Exception e) |
| { |
| e.printStackTrace(); |
| } |
| |
| if (UCharacter.getDirection(0x10001) != |
| UCharacterDirection.LEFT_TO_RIGHT) |
| errln("FAIL 0x10001 expected direction " + |
| UCharacterDirection.toString(UCharacterDirection.LEFT_TO_RIGHT)); |
| } |
| |
| /** |
| * Test for the character names |
| */ |
| public void TestNames() |
| { |
| int c[] = {0x0061, 0x0284, 0x3401, 0x7fed, 0xac00, 0xd7a3, 0xff08, 0xffe5}; |
| String name[] = {"LATIN SMALL LETTER A", |
| "LATIN SMALL LETTER DOTLESS J WITH STROKE AND HOOK", |
| "CJK UNIFIED IDEOGRAPH-3401", |
| "CJK UNIFIED IDEOGRAPH-7FED", "HANGUL SYLLABLE GA", |
| "HANGUL SYLLABLE HIH", "FULLWIDTH LEFT PARENTHESIS", |
| "FULLWIDTH YEN SIGN"}; |
| String oldname[] = {"", "LATIN SMALL LETTER DOTLESS J BAR HOOK", "", "", |
| "", "", "FULLWIDTH OPENING PARENTHESIS", ""}; |
| int size = c.length; |
| String str; |
| int uc; |
| |
| for (int i = 0; i < size; i ++) |
| { |
| // modern Unicode character name |
| str = UCharacter.getName(c[i]); |
| if (!str.equalsIgnoreCase(name[i])) |
| { |
| errln("FAIL 0x" + Integer.toHexString(c[i]) + " expected name " + |
| name[i]); |
| break; |
| } |
| |
| // 1.0 Unicode character name |
| str = UCharacter.getName1_0(c[i]); |
| if ((str == null && oldname[i].length() > 0) || |
| (str != null && !str.equalsIgnoreCase(oldname[i]))) |
| { |
| errln("FAIL 0x" + Integer.toHexString(c[i]) + " expected 1.0 name " + |
| oldname[i]); |
| break; |
| } |
| |
| // retrieving unicode character from modern name |
| uc = UCharacter.getCharFromName(name[i]); |
| if (uc != c[i]) |
| { |
| errln("FAIL " + name[i] + " expected character 0x" + |
| Integer.toHexString(c[i])); |
| break; |
| } |
| |
| //retrieving unicode character from 1.0 name |
| uc = UCharacter.getCharFromName1_0(oldname[i]); |
| if (uc != c[i] && i != 0 && (i == 1 || i == 6)) |
| { |
| errln("FAIL " + name[i] + " expected 1.0 character " + |
| Integer.toHexString(c[i])); |
| break; |
| } |
| } |
| |
| // extra testing different from icu |
| for (int i = UCharacter.MIN_VALUE; i < UCharacter.MAX_VALUE; i ++) |
| { |
| str = UCharacter.getName(i); |
| if (str != null && UCharacter.getCharFromName(str) != i) |
| { |
| errln("FAIL 0x" + Integer.toHexString(i) + " " + str + |
| " retrieval of name and vice versa" ); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * Testing the strings case mapping methods |
| */ |
| public void TestCaseMapping() |
| { |
| String beforeLower = "\u0061\u0042\u0049\u03a3\u00df\u03a3\u002f\ud93f\udfff", |
| lowerRoot = "\u0061\u0062\u0069\u03c3\u00df\u03c2\u002f\ud93f\udfff", |
| lowerTurkish = "\u0061\u0062\u0131\u03c3\u00df\u03c2\u002f\ud93f\udfff", |
| beforeUpper = "\u0061\u0042\u0069\u03c2\u00df\u03c3\u002f\ufb03\ud93f\udfff", |
| upperRoot = "\u0041\u0042\u0049\u03a3\u0053\u0053\u03a3\u002f\u0046\u0046\u0049\ud93f\udfff", |
| upperTurkish = "\u0041\u0042\u0130\u03a3\u0053\u0053\u03a3\u002f\u0046\u0046\u0049\ud93f\udfff"; |
| |
| String result = UCharacter.toLowerCase(beforeLower); |
| if (!lowerRoot.equals(result)) |
| errln("Fail " + beforeLower + " after lowercase should be " + lowerRoot); |
| |
| // lowercase with turkish locale |
| result = UCharacter.toLowerCase(new Locale("tr", "TR"), beforeLower); |
| if (!lowerTurkish.equals(result)) |
| errln("Fail " + beforeLower + " after turkish-sensitive lowercase " + |
| "should be " + lowerRoot); |
| |
| // uppercase with root locale and in the same buffer |
| result = UCharacter.toUpperCase(beforeUpper); |
| if (!upperRoot.equals(result)) |
| errln("Fail " + beforeUpper + " after uppercase should be " + upperRoot); |
| |
| // uppercase with turkish locale and separate buffers |
| result = UCharacter.toUpperCase(new Locale("tr", "TR"), beforeUpper); |
| if (!upperTurkish.equals(result)) |
| errln("Fail " + beforeUpper + " after turkish-sensitive uppercase " + |
| "should be " + upperTurkish); |
| |
| // test preflighting |
| result = UCharacter.toLowerCase(beforeLower); |
| if (!lowerRoot.equals(result)) |
| errln("Fail " + beforeLower + " after lower case should be " + |
| lowerRoot); |
| } |
| |
| |
| public static void main(String[] arg) |
| { |
| try |
| { |
| UCharacterTest test = new UCharacterTest(); |
| test.run(arg); |
| } |
| catch (Exception e) |
| { |
| e.printStackTrace(); |
| } |
| } |
| } |
| |
