| /******************************************************************** |
| * COPYRIGHT: |
| * Copyright (c) 1997-2008, International Business Machines Corporation and |
| * others. All Rights Reserved. |
| ********************************************************************/ |
| |
| #include "unicode/ustring.h" |
| #include "unicode/uchar.h" |
| #include "unicode/uniset.h" |
| #include "unicode/putil.h" |
| #include "cstring.h" |
| #include "uparse.h" |
| #include "ucdtest.h" |
| |
| #define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof(array[0])) |
| |
| 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 = "TestAdditionalProperties"; if(exec) TestAdditionalProperties(); break; |
| case 1: name = "TestBinaryValues"; if(exec) TestBinaryValues(); break; |
| default: name = ""; break; //needed to end loop |
| } |
| } |
| |
| //==================================================== |
| // private data used by the tests |
| //==================================================== |
| |
| // test DerivedCoreProperties.txt ------------------------------------------- |
| |
| // copied from genprops.c |
| static int32_t |
| getTokenIndex(const char *const tokens[], int32_t countTokens, const char *s) { |
| const char *t, *z; |
| int32_t i, j; |
| |
| s=u_skipWhitespace(s); |
| for(i=0; i<countTokens; ++i) { |
| t=tokens[i]; |
| if(t!=NULL) { |
| for(j=0;; ++j) { |
| if(t[j]!=0) { |
| if(s[j]!=t[j]) { |
| break; |
| } |
| } else { |
| z=u_skipWhitespace(s+j); |
| if(*z==';' || *z==0) { |
| return i; |
| } else { |
| break; |
| } |
| } |
| } |
| } |
| } |
| return -1; |
| } |
| |
| static const char *const |
| derivedCorePropsNames[]={ |
| "Math", |
| "Alphabetic", |
| "Lowercase", |
| "Uppercase", |
| "ID_Start", |
| "ID_Continue", |
| "XID_Start", |
| "XID_Continue", |
| "Default_Ignorable_Code_Point", |
| "Grapheme_Extend", |
| "Grapheme_Link", /* Unicode 5 moves this property here from PropList.txt */ |
| "Grapheme_Base" |
| }; |
| |
| static const UProperty |
| derivedCorePropsIndex[]={ |
| UCHAR_MATH, |
| UCHAR_ALPHABETIC, |
| UCHAR_LOWERCASE, |
| UCHAR_UPPERCASE, |
| UCHAR_ID_START, |
| UCHAR_ID_CONTINUE, |
| UCHAR_XID_START, |
| UCHAR_XID_CONTINUE, |
| UCHAR_DEFAULT_IGNORABLE_CODE_POINT, |
| UCHAR_GRAPHEME_EXTEND, |
| UCHAR_GRAPHEME_LINK, |
| UCHAR_GRAPHEME_BASE |
| }; |
| |
| U_CFUNC void U_CALLCONV |
| derivedCorePropsLineFn(void *context, |
| char *fields[][2], int32_t /* fieldCount */, |
| UErrorCode *pErrorCode) |
| { |
| UnicodeTest *me=(UnicodeTest *)context; |
| uint32_t start, end; |
| int32_t i; |
| |
| u_parseCodePointRange(fields[0][0], &start, &end, pErrorCode); |
| if(U_FAILURE(*pErrorCode)) { |
| me->errln("UnicodeTest: syntax error in DerivedCoreProperties.txt field 0 at %s\n", fields[0][0]); |
| return; |
| } |
| |
| /* parse derived binary property name, ignore unknown names */ |
| i=getTokenIndex(derivedCorePropsNames, LENGTHOF(derivedCorePropsNames), fields[1][0]); |
| if(i<0) { |
| me->errln("UnicodeTest warning: unknown property name '%s' in \n", fields[1][0]); |
| return; |
| } |
| |
| me->derivedCoreProps[i].add(start, end); |
| } |
| |
| void UnicodeTest::TestAdditionalProperties() { |
| // test DerivedCoreProperties.txt |
| if(LENGTHOF(derivedCoreProps)<LENGTHOF(derivedCorePropsNames)) { |
| errln("error: UnicodeTest::derivedCoreProps[] too short, need at least %d UnicodeSets\n", |
| LENGTHOF(derivedCorePropsNames)); |
| return; |
| } |
| if(LENGTHOF(derivedCorePropsIndex)!=LENGTHOF(derivedCorePropsNames)) { |
| errln("error in ucdtest.cpp: LENGTHOF(derivedCorePropsIndex)!=LENGTHOF(derivedCorePropsNames)\n"); |
| return; |
| } |
| |
| char newPath[256]; |
| char backupPath[256]; |
| char *fields[2][2]; |
| UErrorCode errorCode=U_ZERO_ERROR; |
| |
| /* Look inside ICU_DATA first */ |
| strcpy(newPath, pathToDataDirectory()); |
| strcat(newPath, "unidata" U_FILE_SEP_STRING "DerivedCoreProperties.txt"); |
| |
| // As a fallback, try to guess where the source data was located |
| // at the time ICU was built, and look there. |
| # ifdef U_TOPSRCDIR |
| strcpy(backupPath, U_TOPSRCDIR U_FILE_SEP_STRING "data"); |
| # else |
| strcpy(backupPath, loadTestData(errorCode)); |
| strcat(backupPath, U_FILE_SEP_STRING ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING "data"); |
| # endif |
| strcat(backupPath, U_FILE_SEP_STRING); |
| strcat(backupPath, "unidata" U_FILE_SEP_STRING "DerivedCoreProperties.txt"); |
| |
| u_parseDelimitedFile(newPath, ';', fields, 2, derivedCorePropsLineFn, this, &errorCode); |
| |
| if(errorCode==U_FILE_ACCESS_ERROR) { |
| errorCode=U_ZERO_ERROR; |
| u_parseDelimitedFile(backupPath, ';', fields, 2, derivedCorePropsLineFn, this, &errorCode); |
| } |
| if(U_FAILURE(errorCode)) { |
| errln("error parsing DerivedCoreProperties.txt: %s\n", u_errorName(errorCode)); |
| return; |
| } |
| |
| // now we have all derived core properties in the UnicodeSets |
| // run them all through the API |
| int32_t rangeCount, range; |
| uint32_t i; |
| UChar32 start, end; |
| int32_t noErrors = 0; |
| |
| // test all TRUE properties |
| for(i=0; i<LENGTHOF(derivedCorePropsNames); ++i) { |
| rangeCount=derivedCoreProps[i].getRangeCount(); |
| for(range=0; range<rangeCount; ++range) { |
| start=derivedCoreProps[i].getRangeStart(range); |
| end=derivedCoreProps[i].getRangeEnd(range); |
| for(; start<=end; ++start) { |
| if(!u_hasBinaryProperty(start, derivedCorePropsIndex[i])) { |
| errln("UnicodeTest error: u_hasBinaryProperty(U+%04lx, %s)==FALSE is wrong\n", start, derivedCorePropsNames[i]); |
| if(noErrors++ > 100) { |
| errln("Too many errors, moving to the next test"); |
| break; |
| } |
| } |
| } |
| } |
| } |
| |
| noErrors = 0; |
| // invert all properties |
| for(i=0; i<LENGTHOF(derivedCorePropsNames); ++i) { |
| derivedCoreProps[i].complement(); |
| } |
| |
| // test all FALSE properties |
| for(i=0; i<LENGTHOF(derivedCorePropsNames); ++i) { |
| rangeCount=derivedCoreProps[i].getRangeCount(); |
| for(range=0; range<rangeCount; ++range) { |
| start=derivedCoreProps[i].getRangeStart(range); |
| end=derivedCoreProps[i].getRangeEnd(range); |
| for(; start<=end; ++start) { |
| if(u_hasBinaryProperty(start, derivedCorePropsIndex[i])) { |
| errln("UnicodeTest error: u_hasBinaryProperty(U+%04lx, %s)==TRUE is wrong\n", start, derivedCorePropsNames[i]); |
| if(noErrors++ > 100) { |
| errln("Too many errors, moving to the next test"); |
| break; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| void UnicodeTest::TestBinaryValues() { |
| /* |
| * Unicode 5.1 explicitly defines binary property value aliases. |
| * Verify that they are all recognized. |
| */ |
| UErrorCode errorCode=U_ZERO_ERROR; |
| UnicodeSet alpha(UNICODE_STRING_SIMPLE("[:Alphabetic:]"), errorCode); |
| if(U_FAILURE(errorCode)) { |
| errln("UnicodeSet([:Alphabetic:]) failed - %s\n", u_errorName(errorCode)); |
| return; |
| } |
| |
| static const char *const falseValues[]={ "N", "No", "F", "False" }; |
| static const char *const trueValues[]={ "Y", "Yes", "T", "True" }; |
| int32_t i; |
| for(i=0; i<LENGTHOF(falseValues); ++i) { |
| UnicodeString pattern=UNICODE_STRING_SIMPLE("[:Alphabetic=:]"); |
| pattern.insert(pattern.length()-2, UnicodeString(falseValues[i], -1, US_INV)); |
| errorCode=U_ZERO_ERROR; |
| UnicodeSet set(pattern, errorCode); |
| if(U_FAILURE(errorCode)) { |
| errln("UnicodeSet([:Alphabetic=%s:]) failed - %s\n", falseValues[i], u_errorName(errorCode)); |
| continue; |
| } |
| set.complement(); |
| if(set!=alpha) { |
| errln("UnicodeSet([:Alphabetic=%s:]).complement()!=UnicodeSet([:Alphabetic:])\n", falseValues[i]); |
| } |
| } |
| for(i=0; i<LENGTHOF(trueValues); ++i) { |
| UnicodeString pattern=UNICODE_STRING_SIMPLE("[:Alphabetic=:]"); |
| pattern.insert(pattern.length()-2, UnicodeString(trueValues[i], -1, US_INV)); |
| errorCode=U_ZERO_ERROR; |
| UnicodeSet set(pattern, errorCode); |
| if(U_FAILURE(errorCode)) { |
| errln("UnicodeSet([:Alphabetic=%s:]) failed - %s\n", trueValues[i], u_errorName(errorCode)); |
| continue; |
| } |
| if(set!=alpha) { |
| errln("UnicodeSet([:Alphabetic=%s:])!=UnicodeSet([:Alphabetic:])\n", trueValues[i]); |
| } |
| } |
| } |
