| /******************************************************************** |
| * COPYRIGHT: |
| * Copyright (c) 1997-2001, International Business Machines Corporation and |
| * others. All Rights Reserved. |
| ********************************************************************/ |
| |
| #include "ucdtest.h" |
| #include "unicode/unicode.h" |
| #include "unicode/ustring.h" |
| #include "unicode/uchar.h" |
| #include "cstring.h" |
| #include "uparse.h" |
| |
| UnicodeTest::UnicodeTest() |
| { |
| } |
| |
| UnicodeTest::~UnicodeTest() |
| { |
| } |
| |
| void UnicodeTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ ) |
| { |
| if (exec) logln("TestSuite UnicodeTest: "); |
| switch (index) { |
| case 0: name = "TestUpperLower"; if (exec) TestUpperLower(); break; |
| case 1: name = "TestLetterNumber"; if (exec) TestLetterNumber(); break; |
| case 2: name = "TestMisc"; if (exec) TestMisc(); break; |
| case 3: name = "TestUnicodeData"; if (exec) TestUnicodeData(); break; |
| case 4: name = "TestCodeUnit"; if(exec) TestCodeUnit(); break; |
| case 5: name = "TestCodePoint"; if(exec) TestCodePoint(); break; |
| case 6: name = "TestCharLength"; if(exec) TestCharLength(); break; |
| case 7: name = "TestIdentifier"; if(exec) TestIdentifier(); break; |
| case 8: name = "TestScript"; if(exec) TestScript(); break; |
| default: name = ""; break; //needed to end loop |
| } |
| } |
| |
| //==================================================== |
| // private data used by the tests |
| //==================================================== |
| |
| const UChar LAST_CHAR_CODE_IN_FILE = 0xFFFD; |
| const char tagStrings[] = "MnMcMeNdNlNoZsZlZpCcCfCsCoCnLuLlLtLmLoPcPdPsPePoSmScSkSoPiPf"; |
| const int32_t tagValues[] = |
| { |
| /* Mn */ Unicode::NON_SPACING_MARK, |
| /* Mc */ Unicode::COMBINING_SPACING_MARK, |
| /* Me */ Unicode::ENCLOSING_MARK, |
| /* Nd */ Unicode::DECIMAL_DIGIT_NUMBER, |
| /* Nl */ Unicode::LETTER_NUMBER, |
| /* No */ Unicode::OTHER_NUMBER, |
| /* Zs */ Unicode::SPACE_SEPARATOR, |
| /* Zl */ Unicode::LINE_SEPARATOR, |
| /* Zp */ Unicode::PARAGRAPH_SEPARATOR, |
| /* Cc */ Unicode::CONTROL, |
| /* Cf */ Unicode::FORMAT, |
| /* Cs */ Unicode::SURROGATE, |
| /* Co */ Unicode::PRIVATE_USE, |
| /* Cn */ Unicode::UNASSIGNED, |
| /* Lu */ Unicode::UPPERCASE_LETTER, |
| /* Ll */ Unicode::LOWERCASE_LETTER, |
| /* Lt */ Unicode::TITLECASE_LETTER, |
| /* Lm */ Unicode::MODIFIER_LETTER, |
| /* Lo */ Unicode::OTHER_LETTER, |
| /* Pc */ Unicode::CONNECTOR_PUNCTUATION, |
| /* Pd */ Unicode::DASH_PUNCTUATION, |
| /* Ps */ Unicode::START_PUNCTUATION, |
| /* Pe */ Unicode::END_PUNCTUATION, |
| /* Po */ Unicode::OTHER_PUNCTUATION, |
| /* Sm */ Unicode::MATH_SYMBOL, |
| /* Sc */ Unicode::CURRENCY_SYMBOL, |
| /* Sk */ Unicode::MODIFIER_SYMBOL, |
| /* So */ Unicode::OTHER_SYMBOL, |
| /* Pi */ Unicode::INITIAL_PUNCTUATION, |
| /* Pf */ Unicode::FINAL_PUNCTUATION |
| }; |
| const char dirStrings[][5] = { |
| "L", |
| "R", |
| "EN", |
| "ES", |
| "ET", |
| "AN", |
| "CS", |
| "B", |
| "S", |
| "WS", |
| "ON", |
| "LRE", |
| "LRO", |
| "AL", |
| "RLE", |
| "RLO", |
| "PDF", |
| "NSM", |
| "BN" |
| }; |
| |
| //==================================================== |
| // test toUpperCase() and toLowerCase() |
| //==================================================== |
| void UnicodeTest::TestUpperLower() |
| { |
| U_STRING_DECL(upperTest, "abcdefg123hij.?:klmno", 21); |
| U_STRING_DECL(lowerTest, "ABCDEFG123HIJ.?:KLMNO", 21); |
| uint16_t i; |
| |
| U_STRING_INIT(upperTest, "abcdefg123hij.?:klmno", 21); |
| U_STRING_INIT(lowerTest, "ABCDEFG123HIJ.?:KLMNO", 21); |
| |
| //Checks LetterLike Symbols which were previously a source of confusion |
| //[Bertrand A. D. 02/04/98] |
| for (i=0x2100;i<0x2138;i++) |
| { |
| if(i!=0x2126 && i!=0x212a && i!=0x212b) |
| { |
| if (i != Unicode::toLowerCase(i)) // itself |
| errln("Failed case conversion with itself: " + UCharToUnicodeString(i)); |
| if (i != Unicode::toUpperCase(i)) |
| errln("Failed case conversion with itself: " + UCharToUnicodeString(i)); |
| } |
| } |
| |
| for (i = 0; i < 21; i++) { |
| // logln((UnicodeString)"testing " + (int32_t)i + "..."); |
| if (Unicode::isLetter(upperTest[i]) && !Unicode::isLowerCase(upperTest[i])) |
| errln("Failed isLowerCase test at " + UCharToUnicodeString(upperTest[i])); |
| else if (Unicode::isLetter(lowerTest[i]) && !Unicode::isUpperCase(lowerTest[i])) |
| errln("Failed isUpperCase test at " + UCharToUnicodeString(lowerTest[i])); |
| else if (upperTest[i] != Unicode::toLowerCase(lowerTest[i])) |
| errln("Failed case conversion : " + UCharToUnicodeString(upperTest[i]) + |
| " to " + UCharToUnicodeString(lowerTest[i])); |
| else if (lowerTest[i] != Unicode::toUpperCase(upperTest[i])) |
| errln("Failed case conversion : " + UCharToUnicodeString(upperTest[i]) + |
| " to " + UCharToUnicodeString(lowerTest[i])); |
| else if (upperTest[i] != Unicode::toLowerCase(upperTest[i])) // itself |
| errln("Failed case conversion with itself: " + UCharToUnicodeString(upperTest[i])); |
| else if (lowerTest[i] != Unicode::toUpperCase(lowerTest[i])) |
| errln("Failed case conversion with itself: " + UCharToUnicodeString(lowerTest[i])); |
| } |
| } |
| |
| /* test isLetter() and isDigit() */ |
| void UnicodeTest::TestLetterNumber() |
| { |
| UChar i; |
| |
| for (i = 0x0041; i < 0x005B; i++) { |
| // logln((UnicodeString)"testing " + (int32_t)i + "..."); |
| if (!Unicode::isLetter(i)) |
| errln("Failed isLetter test at " + UCharToUnicodeString(i)); |
| } |
| for (i = 0x0660; i < 0x066A; i++) { |
| // logln((UnicodeString)"testing " + (int32_t)i + "..."); |
| if (Unicode::isLetter(i)) |
| errln("Failed isLetter test with numbers at " + i); |
| } |
| for (i = 0x0660; i < 0x066A; i++) { |
| // logln((UnicodeString)"testing " + (int32_t)i + "..."); |
| if (!Unicode::isDigit(i)) |
| errln("Failed isNumber test at " + i); |
| } |
| } |
| |
| /* Tests for isDefined(), isBaseForm(), isSpaceChar() and getCellWidth() */ |
| void UnicodeTest::TestMisc() |
| { |
| const UChar sampleSpaces[] = {0x0020, 0x00a0, 0x2000, 0x2001, 0x2005}; |
| const UChar sampleNonSpaces[] = {0x61, 0x62, 0x63, 0x64, 0x74}; |
| const UChar sampleWhiteSpaces[] = {0x2008, 0x2009, 0x200a, 0x001c, 0x000c}; |
| const UChar sampleNonWhiteSpaces[] = {0x61, 0x62, 0x3c, 0x28, 0x3f}; |
| const UChar sampleUndefined[] = {0xfff1, 0xfff7, 0xfa30}; |
| const UChar sampleDefined[] = {0x523E, 0x4f88, 0xfffd}; |
| const UChar sampleBase[] = {0x0061, 0x0031, 0x03d2}; |
| const UChar sampleNonBase[] = {0x002B, 0x0020, 0x203B}; |
| const UChar sampleChars[] = {0x000a, 0x0045, 0x4e00, 0xDC00}; |
| const UChar sampleDigits[]= {0x0030, 0x0662, 0x0F23, 0x0ED5}; |
| const UChar sampleNonDigits[] = {0x0010, 0x0041, 0x0122, 0x68FE}; |
| const int32_t sampleDigitValues[] = {0, 2, 3, 5}; |
| const uint16_t sampleCellWidth[] = {Unicode::ZERO_WIDTH, |
| Unicode::HALF_WIDTH, |
| Unicode::FULL_WIDTH, |
| Unicode::NEUTRAL}; |
| int32_t i; |
| for (i = 0; i < 5; i++) { |
| // logln((UnicodeString)"testing " + (int32_t)i + "..."); |
| if (!(Unicode::isSpaceChar(sampleSpaces[i])) || |
| (Unicode::isSpaceChar(sampleNonSpaces[i]))) |
| errln((UnicodeString)"Space char test error : " + (int32_t)sampleSpaces[i] + |
| " or " + (int32_t)sampleNonSpaces[i]); |
| } |
| for (i = 0; i < 5; i++) { |
| // log_ln("Testing for isWhitespace and nonWhitespaces\n"); |
| if (!(Unicode::isWhitespace(sampleWhiteSpaces[i])) || |
| (Unicode::isWhitespace(sampleNonWhiteSpaces[i]))) |
| { |
| errln((UnicodeString)"White Space char test error : " + (int32_t)sampleWhiteSpaces[i] + |
| "or" + (int32_t)sampleNonWhiteSpaces[i]); |
| } |
| } |
| for (i = 0; i < 3; i++) { |
| // logln((UnicodeString)"testing " + (int32_t)i + "..."); |
| if ((Unicode::isDefined(sampleUndefined[i])) || |
| !(Unicode::isDefined(sampleDefined[i]))) |
| errln((UnicodeString)"Undefined char test error : " + |
| (int32_t)sampleUndefined[i] + " or " + (int32_t)sampleDefined[i]); |
| } |
| for (i = 0; i < 3; i++) { |
| // logln((UnicodeString)"testing " + (int32_t)i + "..."); |
| if ((Unicode::isBaseForm(sampleNonBase[i])) || |
| !(Unicode::isBaseForm(sampleBase[i]))) |
| errln((UnicodeString)"Non-baseform char test error : " + |
| (int32_t)sampleNonBase[i] + " or " + (int32_t)sampleBase[i]); |
| } |
| for (i = 0; i < 4; i++) { |
| // logln((UnicodeString)"testing " + (int32_t)i + "..."); |
| if (Unicode::getCellWidth(sampleChars[i]) != sampleCellWidth[i]) |
| errln((UnicodeString)"Cell width char test error : " + |
| (int32_t)sampleChars[i]); |
| } |
| for (i = 0; i < 4; i++) { |
| if ((Unicode::isDigit(sampleDigits[i]) && |
| (Unicode::digitValue(sampleDigits[i])!= sampleDigitValues[i])) || |
| (Unicode::isDigit(sampleNonDigits[i]))) { |
| errln((UnicodeString)"Digit char test error : " + |
| (int32_t)sampleDigits[i] + " or " + (int32_t)sampleNonDigits[i]); |
| } |
| } |
| } |
| |
| /* Tests for isControl() and isPrintable() */ |
| void UnicodeTest::TestControlPrint() |
| { |
| const UChar sampleControl[] = {0x001b, 0x0097, 0x0082}; |
| const UChar sampleNonControl[] = {0x61, 0x0031, 0x00e2}; |
| const UChar samplePrintable[] = {0x0042, 0x005f, 0x2014}; |
| const UChar sampleNonPrintable[] = {0x200c, 0x009f, 0x001b}; |
| int32_t i; |
| for (i = 0; i < 3; i++) { |
| // logln((UnicodeString)"testing " + (int32_t)i + "..."); |
| if (!(Unicode::isControl(sampleControl[i])) || |
| (Unicode::isControl(sampleNonControl[i]))) |
| errln((UnicodeString)"Control char test error : " + (int32_t)sampleControl[i] + |
| " or " + (int32_t)sampleNonControl[i]); |
| } |
| for (i = 0; i < 3; i++) { |
| // logln((UnicodeString)"testing " + (int32_t)i + "..."); |
| if ((Unicode::isPrintable(samplePrintable[i])) || |
| !(Unicode::isPrintable(samplePrintable[i]))) |
| errln((UnicodeString)"Printable char test error : " + |
| (int32_t)samplePrintable[i] + " or " + (int32_t)sampleNonPrintable[i]); |
| } |
| } |
| |
| /* Tests for isJavaIdentifierStart(), isJavaIdentifierPart(), |
| * isUnicodeIdentifierStart() and isUnicodeIdentifierPart() */ |
| void UnicodeTest::TestIdentifier() |
| { |
| const UChar sampleJavaIDStart[] = {0x0071, 0x00e4, 0x005f}; |
| const UChar sampleNonJavaIDStart[] = {0x0020, 0x2030, 0x0082}; |
| const UChar sampleUnicodeIDStart[] = {0x0250, 0x00e2, 0x0061}; |
| const UChar sampleNonUnicodeIDStart[] = {0x2000, 0x000a, 0x2019}; |
| const UChar sampleJavaIDPart[] = {0x005f, 0x0032, 0x0045}; |
| const UChar sampleNonJavaIDPart[] = {0x2030, 0x2020, 0x0020}; |
| const UChar sampleUnicodeIDPart[] = {0x005f, 0x0032, 0x0045}; |
| const UChar sampleNonUnicodeIDPart[] = {0x2030, 0x00a3, 0x0020}; |
| const UChar sampleIDIgnore[] = {0x0006, 0x0010, 0x206b}; |
| const UChar sampleNonIDIgnore[] = {0x0075, 0x00a3, 0x0061}; |
| |
| int32_t i; |
| for (i = 0; i < 3; i++) { |
| // logln((UnicodeString)"testing " + (int32_t)i + "..."); |
| if (!(Unicode::isJavaIdentifierStart(sampleJavaIDStart[i])) || |
| (Unicode::isJavaIdentifierStart(sampleNonJavaIDStart[i]))) |
| errln((UnicodeString)"Java ID Start char test error : " + (int32_t)sampleJavaIDStart[i] + |
| " or " + (int32_t)sampleNonJavaIDStart[i]); |
| } |
| for (i = 0; i < 3; i++) { |
| // logln((UnicodeString)"testing " + (int32_t)i + "..."); |
| if (!(Unicode::isJavaIdentifierPart(sampleJavaIDPart[i])) || |
| (Unicode::isJavaIdentifierPart(sampleNonJavaIDPart[i]))) |
| errln((UnicodeString)"Java ID Part char test error : " + (int32_t)sampleJavaIDPart[i] + |
| " or " + (int32_t)sampleNonJavaIDPart[i]); |
| } |
| for (i = 0; i < 3; i++) { |
| // logln((UnicodeString)"testing " + (int32_t)i + "..."); |
| if (!(Unicode::isUnicodeIdentifierStart(sampleUnicodeIDStart[i])) || |
| (Unicode::isUnicodeIdentifierStart(sampleNonUnicodeIDStart[i]))) |
| errln((UnicodeString)"Unicode ID Start char test error : " + (int32_t)sampleUnicodeIDStart[i] + |
| " or " + (int32_t)sampleNonUnicodeIDStart[i]); |
| } |
| for (i = 0; i < 3; i++) { |
| // logln((UnicodeString)"testing " + (int32_t)i + "..."); |
| if (!(Unicode::isUnicodeIdentifierPart(sampleUnicodeIDPart[i])) || |
| (Unicode::isUnicodeIdentifierPart(sampleNonUnicodeIDPart[i]))) |
| errln((UnicodeString)"Unicode ID Part char test error : " + (int32_t)sampleUnicodeIDPart[i] + |
| " or " + (int32_t)sampleNonUnicodeIDPart[i]); |
| } |
| for (i = 0; i < 3; i++) { |
| // logln((UnicodeString)"testing " + (int32_t)i + "..."); |
| if (!(Unicode::isIdentifierIgnorable(sampleIDIgnore[i])) || |
| (Unicode::isIdentifierIgnorable(sampleNonIDIgnore[i]))) |
| errln((UnicodeString)"ID ignorable char test error : " + (int32_t)sampleIDIgnore[i] + |
| " or " + (int32_t)sampleNonIDIgnore[i]); |
| } |
| } |
| |
| /* for each line of UnicodeData.txt, check some of the properties */ |
| void U_CALLCONV |
| UnicodeTest::unicodeDataLineFn(void *context, |
| char *fields[][2], int32_t fieldCount, |
| UErrorCode *pErrorCode) { |
| char *end; |
| uint32_t value; |
| UChar32 c; |
| int8_t type; |
| UnicodeTest *me=(UnicodeTest *)context; |
| |
| if(U_FAILURE(*pErrorCode)) { |
| me->errln("error: unicodeDataLineFn called with pErrorCode=%d\n", pErrorCode); |
| return; |
| } |
| |
| if(fieldCount != 15) { |
| me->errln("error in UnicodeData.txt: The data format changed. fieldCount=%lu and it should be 15\n", fieldCount); |
| *pErrorCode = U_PARSE_ERROR; |
| return; |
| } |
| |
| /* get the character code, field 0 */ |
| c=(UChar32)uprv_strtoul(fields[0][0], &end, 16); |
| if(end<=fields[0][0] || end!=fields[0][1]) { |
| me->errln("error: syntax error in field 0 at %s\n" + UnicodeString(fields[0][0], "")); |
| *pErrorCode = U_PARSE_ERROR; |
| return; |
| } |
| if((uint32_t)c>=0x110000) { |
| me->errln("error in UnicodeData.txt: code point %lu out of range\n", c); |
| *pErrorCode = U_PARSE_ERROR; |
| return; |
| } |
| |
| /* get general category, field 2 */ |
| /* we override the general category of some control characters */ |
| switch(c) { |
| case 9: |
| case 0xb: |
| case 0x1f: |
| type = U_SPACE_SEPARATOR; |
| break; |
| case 0xc: |
| type = U_LINE_SEPARATOR; |
| break; |
| case 0xa: |
| case 0xd: |
| case 0x1c: |
| case 0x1d: |
| case 0x1e: |
| case 0x85: |
| type = U_PARAGRAPH_SEPARATOR; |
| break; |
| default: |
| *fields[2][1]=0; |
| type = (int8_t)tagValues[me->MakeProp(fields[2][0])]; |
| break; |
| } |
| if(Unicode::getType(c)!=type) { |
| me->errln("error: Unicode::getType(U+%04lx)==%u instead of %u\n", c, Unicode::getType(c), type); |
| *pErrorCode = U_PARSE_ERROR; |
| return; |
| } |
| |
| /* get canonical combining class, field 3 */ |
| value=(uint32_t)uprv_strtoul(fields[3][0], &end, 10); |
| if(end<=fields[3][0] || end!=fields[3][1]) { |
| me->errln("error: syntax error in field 3 at code 0x%lx\n", c); |
| *pErrorCode = U_PARSE_ERROR; |
| return; |
| } |
| if(value>255) { |
| me->errln("error in UnicodeData.txt: combining class %lu out of range\n", value); |
| *pErrorCode = U_PARSE_ERROR; |
| return; |
| } |
| if(value!=Unicode::getCombiningClass(c)) { |
| me->errln("error: Unicode::getCombiningClass(U+%04lx)==%hu instead of %lu\n", c, Unicode::getCombiningClass(c), value); |
| *pErrorCode = U_PARSE_ERROR; |
| return; |
| } |
| |
| /* get BiDi category, field 4 */ |
| *fields[4][1]=0; |
| if(Unicode::characterDirection(c)!=me->MakeDir(fields[4][0])) { |
| me->errln("error: Unicode::characterDirection(U+%04lx)==%u instead of %u (%s)\n", c, Unicode::characterDirection(c), me->MakeDir(fields[4][0]), fields[4][0]); |
| *pErrorCode = U_PARSE_ERROR; |
| return; |
| } |
| |
| /* get uppercase mapping, field 12 */ |
| if(fields[12][0]!=fields[12][1]) { |
| value=(uint32_t)uprv_strtoul(fields[12][0], &end, 16); |
| if(end!=fields[12][1]) { |
| me->errln("error: syntax error in field 12 at code 0x%lx\n", c); |
| *pErrorCode = U_PARSE_ERROR; |
| return; |
| } |
| if((UChar32)value!=Unicode::toUpperCase(c)) { |
| me->errln("error: Unicode::toUpperCase(U+%04lx)==U+%04lx instead of U+%04lx\n", c, Unicode::toUpperCase(c), value); |
| *pErrorCode = U_PARSE_ERROR; |
| return; |
| } |
| } else { |
| /* no case mapping: the API must map the code point to itself */ |
| if(c!=Unicode::toUpperCase(c)) { |
| me->errln("error: U+%04lx does not have an uppercase mapping but Unicode::toUpperCase()==U+%04lx\n", c, Unicode::toUpperCase(c)); |
| *pErrorCode = U_PARSE_ERROR; |
| return; |
| } |
| } |
| |
| /* get lowercase mapping, field 13 */ |
| if(fields[13][0]!=fields[13][1]) { |
| value=(uint32_t)uprv_strtoul(fields[13][0], &end, 16); |
| if(end!=fields[13][1]) { |
| me->errln("error: syntax error in field 13 at code 0x%lx\n", c); |
| *pErrorCode = U_PARSE_ERROR; |
| return; |
| } |
| if((UChar32)value!=Unicode::toLowerCase(c)) { |
| me->errln("error: Unicode::toLowerCase(U+%04lx)==U+%04lx instead of U+%04lx\n", c, Unicode::toLowerCase(c), value); |
| *pErrorCode = U_PARSE_ERROR; |
| return; |
| } |
| } else { |
| /* no case mapping: the API must map the code point to itself */ |
| if(c!=Unicode::toLowerCase(c)) { |
| me->errln("error: U+%04lx does not have a lowercase mapping but Unicode::toLowerCase()==U+%04lx\n", c, Unicode::toLowerCase(c)); |
| *pErrorCode = U_PARSE_ERROR; |
| return; |
| } |
| } |
| |
| /* get titlecase mapping, field 14 */ |
| if(fields[14][0]!=fields[14][1]) { |
| value=(uint32_t)uprv_strtoul(fields[14][0], &end, 16); |
| if(end!=fields[14][1]) { |
| me->errln("error: syntax error in field 14 at code 0x%lx\n", c); |
| *pErrorCode = U_PARSE_ERROR; |
| return; |
| } |
| if((UChar32)value!=Unicode::toTitleCase(c)) { |
| me->errln("error: Unicode::toTitleCase(U+%04lx)==U+%04lx instead of U+%04lx\n", c, Unicode::toTitleCase(c), value); |
| *pErrorCode = U_PARSE_ERROR; |
| return; |
| } |
| } else { |
| /* no case mapping: the API must map the code point to itself */ |
| if(c!=Unicode::toTitleCase(c)) { |
| me->errln("error: U+%04lx does not have a titlecase mapping but Unicode::toTitleCase()==U+%04lx\n", c, Unicode::toTitleCase(c)); |
| *pErrorCode = U_PARSE_ERROR; |
| return; |
| } |
| } |
| } |
| |
| /* tests for several properties */ |
| void UnicodeTest::TestUnicodeData() |
| { |
| char newPath[256]; |
| char backupPath[256]; |
| char *fields[15][2]; |
| UErrorCode errorCode; |
| |
| /* Look inside ICU_DATA first */ |
| strcpy(newPath, u_getDataDirectory()); |
| strcat(newPath, "unidata" U_FILE_SEP_STRING "UnicodeData.txt"); |
| |
| |
| // As a fallback, try to guess where the source data was located |
| // at the time ICU was built, and look there. |
| #if defined (U_TOPSRCDIR) |
| strcpy(backupPath, U_TOPSRCDIR U_FILE_SEP_STRING ".." U_FILE_SEP_STRING "data"); |
| #else |
| strcpy(backupPath, u_getDataDirectory()); |
| strcat(backupPath, ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING "data"); |
| #endif |
| strcat(backupPath, U_FILE_SEP_STRING); |
| strcat(backupPath, "unidata" U_FILE_SEP_STRING "UnicodeData.txt"); |
| |
| errorCode=U_ZERO_ERROR; |
| u_parseDelimitedFile(backupPath, ';', fields, 15, unicodeDataLineFn, this, &errorCode); |
| if(errorCode==U_FILE_ACCESS_ERROR) { |
| errorCode=U_ZERO_ERROR; |
| u_parseDelimitedFile(newPath, ';', fields, 15, unicodeDataLineFn, this, &errorCode); |
| } |
| if(U_FAILURE(errorCode)) { |
| errln("error parsing UnicodeData.txt: %s\n" + UnicodeString(u_errorName(errorCode), "")); |
| return; |
| } |
| |
| // test Unicode::getCharName() |
| // a more thorough test of u_charName() is in cintltst/cucdtst.c |
| char buffer[100]; |
| UTextOffset length=Unicode::getCharName(0x284, buffer, (UTextOffset)sizeof(buffer)); |
| |
| // use invariant-character conversion to Unicode |
| UnicodeString name(buffer, length, ""); |
| if(name!=UNICODE_STRING("LATIN SMALL LETTER DOTLESS J WITH STROKE AND HOOK", 49)) { |
| errln("Unicode character name lookup failed\n"); |
| } |
| |
| // test Unicode::isMirrored() and charMirror() |
| // see also cintltst/cucdtest.c |
| if(!(Unicode::isMirrored(0x28) && Unicode::isMirrored(0xbb) && Unicode::isMirrored(0x2045) && Unicode::isMirrored(0x232a) && |
| !Unicode::isMirrored(0x27) && !Unicode::isMirrored(0x61) && !Unicode::isMirrored(0x284) && !Unicode::isMirrored(0x3400) |
| ) |
| ) { |
| errln("Unicode::isMirrored() does not work correctly\n"); |
| } |
| |
| if(!(Unicode::charMirror(0x3c)==0x3e && Unicode::charMirror(0x5d)==0x5b && Unicode::charMirror(0x208d)==0x208e && Unicode::charMirror(0x3017)==0x3016 && |
| Unicode::charMirror(0x2e)==0x2e && Unicode::charMirror(0x6f3)==0x6f3 && Unicode::charMirror(0x301c)==0x301c && Unicode::charMirror(0xa4ab)==0xa4ab |
| ) |
| ) { |
| errln("Unicode::charMirror() does not work correctly\n"); |
| } |
| } |
| |
| int32_t UnicodeTest::MakeProp(char* str) |
| { |
| int32_t result = 0; |
| const char* matchPosition; |
| |
| matchPosition = strstr(tagStrings, str); |
| if (matchPosition == 0) errln((UnicodeString)"unrecognized type letter " + str); |
| else result = ((matchPosition - tagStrings) / 2); |
| return result; |
| } |
| |
| int32_t UnicodeTest::MakeDir(char* str) |
| { |
| int32_t pos = 0; |
| for (pos = 0; pos < 19; pos++) { |
| if (strcmp(str, dirStrings[pos]) == 0) { |
| return pos; |
| } |
| } |
| return -1; |
| } |
| /*Tests added by Madhu*/ |
| |
| /* Tests for isSingle(), isLead(), isTrial(), isSurrogate */ |
| void UnicodeTest::TestCodeUnit(){ |
| const UChar codeunit[]={0x0000,0xe065,0x20ac,0xd7ff,0xd800,0xd841,0xd905,0xdbff,0xdc00,0xdc02,0xddee,0xdfff,0}; |
| |
| int32_t i; |
| |
| for(i=0; i<(int32_t)(sizeof(codeunit)/sizeof(codeunit[0])); i++){ |
| UChar c=codeunit[i]; |
| UnicodeString msg; |
| msg.append((UChar32)c); |
| logln((UnicodeString)"Testing code unit value of " + prettify(msg)); |
| if(i<4){ |
| if(!(Unicode::isSingle(c)) || (Unicode::isLead(c)) || (Unicode::isTrail(c)) ||(Unicode::isSurrogate(c))){ |
| errln((UnicodeString)"ERROR:" + prettify(msg) + " is a single"); |
| } |
| |
| } |
| if(i >= 4 && i< 8){ |
| if(!(Unicode::isLead(c)) || Unicode::isSingle(c) || Unicode::isTrail(c) || !(Unicode::isSurrogate(c))){ |
| errln((UnicodeString)"ERROR:" + prettify(msg) + " is a first surrogate"); |
| } |
| } |
| if(i >= 8 && i< 12){ |
| if(!(Unicode::isTrail(c)) || Unicode::isSingle(c) || Unicode::isLead(c) || !(Unicode::isSurrogate(c))){ |
| errln((UnicodeString)"ERROR:" + prettify(msg) + " is a second surrogate"); |
| } |
| } |
| } |
| |
| } |
| /* Tests for isSurrogate(), isUnicodeChar(), isError(), isValid() */ |
| void UnicodeTest::TestCodePoint(){ |
| const UChar32 codePoint[]={ |
| //surrogate, notvalid(codepoint), not a UnicodeChar, not Error |
| 0xd800, |
| 0xdbff, |
| 0xdc00, |
| 0xdfff, |
| 0xdc04, |
| 0xd821, |
| //not a surrogate, valid, isUnicodeChar , not Error |
| 0x20ac, |
| 0xd7ff, |
| 0xe000, |
| 0xe123, |
| 0x0061, |
| 0xe065, |
| 0x20402, |
| 0x24506, |
| 0x23456, |
| 0x20402, |
| 0x10402, |
| 0x23456, |
| //not a surrogate, not valid, isUnicodeChar, isError |
| 0x0015, |
| 0x009f, |
| //not a surrogate, not valid, not isUnicodeChar, isError |
| 0xffff, |
| 0xfffe, |
| }; |
| int32_t i; |
| for(i=0; i<(int32_t)(sizeof(codePoint)/sizeof(codePoint[0])); i++){ |
| UChar32 c=codePoint[i]; |
| UnicodeString msg; |
| msg.append(c); |
| logln((UnicodeString)"Testing code Point value of " + prettify(msg)); |
| if(i<6){ |
| if(!Unicode::isSurrogate(c)){ |
| errln((UnicodeString)"ERROR: isSurrogate() failed for" + prettify(msg)); |
| } |
| if(Unicode::isValid(c)){ |
| errln((UnicodeString)"ERROR: isValid() failed for "+ prettify(msg)); |
| } |
| if(Unicode::isUnicodeChar(c)){ |
| errln((UnicodeString)"ERROR: isUnicodeChar() failed for "+ prettify(msg)); |
| } |
| if(Unicode::isError(c)){ |
| errln((UnicodeString)"ERROR: isError() failed for "+ prettify(msg)); |
| } |
| }else if(i >=6 && i<18){ |
| if(Unicode::isSurrogate(c)){ |
| errln((UnicodeString)"ERROR: isSurrogate() failed for" + prettify(msg)); |
| } |
| if(!Unicode::isValid(c)){ |
| errln((UnicodeString)"ERROR: isValid() failed for "+ prettify(msg)); |
| } |
| if(!Unicode::isUnicodeChar(c)){ |
| errln((UnicodeString)"ERROR: isUnicodeChar() failed for "+ prettify(msg)); |
| } |
| if(Unicode::isError(c)){ |
| errln((UnicodeString)"ERROR: isError() failed for "+ prettify(msg)); |
| } |
| }else if(i >=18 && i<20){ |
| if(Unicode::isSurrogate(c)){ |
| errln((UnicodeString)"ERROR: isSurrogate() failed for" + prettify(msg)); |
| } |
| if(Unicode::isValid(c)){ |
| errln((UnicodeString)"ERROR: isValid() failed for "+ prettify(msg)); |
| } |
| if(!Unicode::isUnicodeChar(c)){ |
| errln((UnicodeString)"ERROR: isUnicodeChar() failed for "+ prettify(msg)); |
| } |
| if(!Unicode::isError(c)){ |
| errln((UnicodeString)"ERROR: isError() failed for "+ prettify(msg)); |
| } |
| } |
| else if(i >=18 && i<(int32_t)(sizeof(codePoint)/sizeof(codePoint[0]))){ |
| if(Unicode::isSurrogate(c)){ |
| errln((UnicodeString)"ERROR: isSurrogate() failed for" + prettify(msg)); |
| } |
| if(Unicode::isValid(c)){ |
| errln((UnicodeString)"ERROR: isValid() failed for "+ prettify(msg)); |
| } |
| if(Unicode::isUnicodeChar(c)){ |
| errln((UnicodeString)"ERROR: isUnicodeChar() failed for "+ prettify(msg)); |
| } |
| if(!Unicode::isError(c)){ |
| errln((UnicodeString)"ERROR: isError() failed for "+ prettify(msg)); |
| } |
| } |
| } |
| |
| } |
| |
| void UnicodeTest::TestCharLength() |
| { |
| const int32_t codepoint[]={ |
| 1, 0x0061, |
| 1, 0xe065, |
| 1, 0x20ac, |
| 2, 0x20402, |
| 2, 0x23456, |
| 2, 0x24506, |
| 2, 0x20402, |
| 2, 0x10402, |
| 1, 0xd7ff, |
| 1, 0xe000 |
| }; |
| |
| int32_t i; |
| UBool multiple; |
| for(i=0; i<(int32_t)(sizeof(codepoint)/sizeof(codepoint[0])); i=(int16_t)(i+2)){ |
| UChar32 c=codepoint[i+1]; |
| UnicodeString msg; |
| msg.append(c); |
| if(Unicode::charLength(c) != codepoint[i]){ |
| errln((UnicodeString)"The no: of code units for" + prettify(msg)+ |
| ":- Expected: " + (int32_t)codepoint[i] + " Got: " + Unicode::charLength(c)); |
| }else{ |
| logln((UnicodeString)"The no: of code units for" + prettify(msg) + " is " + Unicode::charLength(c)); |
| } |
| multiple=(UBool)(codepoint[i] == 1 ? FALSE : TRUE); |
| if(Unicode::needMultipleUChar(c) != multiple){ |
| errln("ERROR: Unicode::needMultipleUChar() failed for" + prettify(msg)); |
| } |
| } |
| } |
| |
| /* |
| Various script value testing. |
| This makes sure that the Unicode::EUnicodeScript |
| and UCharScript enum values are the same. |
| */ |
| void UnicodeTest::TestScript() |
| { |
| if ((int32_t)Unicode::kScriptCount != (int32_t)UBLOCK_COUNT) { |
| errln("ERROR: Unicode::EUnicodeScript is not the same size as UCharScript"); |
| } |
| |
| if ((int32_t)Unicode::kBasicLatin != (int32_t)U_BASIC_LATIN) { |
| errln("ERROR: Different Basic Latin values in EUnicodeScript and UCharScript"); |
| } |
| |
| if ((int32_t)Unicode::kHighSurrogate != (int32_t)U_HIGH_SURROGATES) { |
| errln("ERROR: Different High Surrogate values in EUnicodeScript and UCharScript"); |
| } |
| |
| if ((int32_t)Unicode::kLowSurrogate != (int32_t)U_LOW_SURROGATES) { |
| errln("ERROR: Different Low Surrogate values in EUnicodeScript and UCharScript"); |
| } |
| |
| if ((int32_t)Unicode::kCJKRadicalsSupplement != (int32_t)U_CJK_RADICALS_SUPPLEMENT) { |
| errln("ERROR: Different CJK Radicals Supplement values in EUnicodeScript and UCharScript"); |
| } |
| |
| if ((int32_t)Unicode::kGreek != (int32_t)U_GREEK) { |
| errln("ERROR: Different Greek values in EUnicodeScript and UCharScript"); |
| } |
| |
| if ((int32_t)Unicode::kThai != (int32_t)U_THAI) { |
| errln("ERROR: Diffe rent Thai values in EUnicodeScript and UCharScript"); |
| } |
| } |
