Home | History | Annotate | Download | only in intltest 
      1 /********************************************************************
      2  * COPYRIGHT:
      3  * Copyright (c) 2002-2014, International Business Machines Corporation and
      4  * others. All Rights Reserved.
      5  ********************************************************************/
      6 
      7 /**
      8  * UCAConformanceTest performs conformance tests defined in the data
      9  * files. ICU ships with stub data files, as the whole test are too
     10  * long. To do the whole test, download the test files.
     11  */
     12 
     13 #include "unicode/utypes.h"
     14 
     15 #if !UCONFIG_NO_COLLATION
     16 
     17 #include "ucaconf.h"
     18 #include "unicode/sortkey.h"
     19 #include "unicode/tblcoll.h"
     20 #include "unicode/ustring.h"
     21 #include "cmemory.h"
     22 #include "cstring.h"
     23 #include "uparse.h"
     24 
     25 UCAConformanceTest::UCAConformanceTest() :
     26 rbUCA(NULL),
     27 testFile(NULL),
     28 status(U_ZERO_ERROR)
     29 {
     30     UCA = (RuleBasedCollator *)Collator::createInstance(Locale::getRoot(), status);
     31     if(U_FAILURE(status)) {
     32         dataerrln("Error - UCAConformanceTest: Unable to open UCA collator! - %s", u_errorName(status));
     33     }
     34 
     35     const char *srcDir = IntlTest::getSourceTestData(status);
     36     if (U_FAILURE(status)) {
     37         dataerrln("Could not open test data %s", u_errorName(status));
     38         return;
     39     }
     40     uprv_strcpy(testDataPath, srcDir);
     41     uprv_strcat(testDataPath, "CollationTest_");
     42 
     43     UVersionInfo uniVersion;
     44     static const UVersionInfo v62 = { 6, 2, 0, 0 };
     45     u_getUnicodeVersion(uniVersion);
     46     isAtLeastUCA62 = uprv_memcmp(uniVersion, v62, 4) >= 0;
     47 }
     48 
     49 UCAConformanceTest::~UCAConformanceTest()
     50 {
     51     delete UCA;
     52     delete rbUCA;
     53     if (testFile) {
     54         fclose(testFile);
     55     }
     56 }
     57 
     58 void UCAConformanceTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par */)
     59 {
     60     if(exec) {
     61         logln("TestSuite UCAConformanceTest: ");
     62     }
     63     TESTCASE_AUTO_BEGIN;
     64     TESTCASE_AUTO(TestTableNonIgnorable);
     65     TESTCASE_AUTO(TestTableShifted);
     66     TESTCASE_AUTO(TestRulesNonIgnorable);
     67     TESTCASE_AUTO(TestRulesShifted);
     68     TESTCASE_AUTO_END;
     69 }
     70 
     71 void UCAConformanceTest::initRbUCA()
     72 {
     73     if(!rbUCA) {
     74         if (UCA) {
     75             UnicodeString ucarules;
     76             UCA->getRules(UCOL_FULL_RULES, ucarules);
     77             rbUCA = new RuleBasedCollator(ucarules, status);
     78             if (U_FAILURE(status)) {
     79                 dataerrln("Failure creating UCA rule-based collator: %s", u_errorName(status));
     80                 return;
     81             }
     82         } else {
     83             dataerrln("Failure creating UCA rule-based collator: %s", u_errorName(status));
     84             return;
     85         }
     86     }
     87 }
     88 
     89 void UCAConformanceTest::setCollNonIgnorable(Collator *coll)
     90 {
     91     coll->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
     92     coll->setAttribute(UCOL_CASE_FIRST, UCOL_OFF, status);
     93     coll->setAttribute(UCOL_CASE_LEVEL, UCOL_OFF, status);
     94     coll->setAttribute(UCOL_STRENGTH, isAtLeastUCA62 ? UCOL_IDENTICAL : UCOL_TERTIARY, status);
     95     coll->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_NON_IGNORABLE, status);
     96 }
     97 
     98 void UCAConformanceTest::setCollShifted(Collator *coll)
     99 {
    100     coll->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
    101     coll->setAttribute(UCOL_CASE_FIRST, UCOL_OFF, status);
    102     coll->setAttribute(UCOL_CASE_LEVEL, UCOL_OFF, status);
    103     coll->setAttribute(UCOL_STRENGTH, isAtLeastUCA62 ? UCOL_IDENTICAL : UCOL_QUATERNARY, status);
    104     coll->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, status);
    105 }
    106 
    107 void UCAConformanceTest::openTestFile(const char *type)
    108 {
    109     const char *ext = ".txt";
    110     if(testFile) {
    111         fclose(testFile);
    112     }
    113     char buffer[1024];
    114     uprv_strcpy(buffer, testDataPath);
    115     uprv_strcat(buffer, type);
    116     int32_t bufLen = (int32_t)uprv_strlen(buffer);
    117 
    118     // we try to open 3 files:
    119     // path/CollationTest_type.txt
    120     // path/CollationTest_type_SHORT.txt
    121     // path/CollationTest_type_STUB.txt
    122     // we are going to test with the first one that we manage to open.
    123 
    124     uprv_strcpy(buffer+bufLen, ext);
    125 
    126     testFile = fopen(buffer, "rb");
    127 
    128     if(testFile == 0) {
    129         uprv_strcpy(buffer+bufLen, "_SHORT");
    130         uprv_strcat(buffer, ext);
    131         testFile = fopen(buffer, "rb");
    132 
    133         if(testFile == 0) {
    134             uprv_strcpy(buffer+bufLen, "_STUB");
    135             uprv_strcat(buffer, ext);
    136             testFile = fopen(buffer, "rb");
    137 
    138             if (testFile == 0) {
    139                 *(buffer+bufLen) = 0;
    140                 dataerrln("Could not open any of the conformance test files, tried opening base %s\n", buffer);
    141                 return;
    142             } else {
    143                 infoln(
    144                     "INFO: Working with the stub file.\n"
    145                     "If you need the full conformance test, please\n"
    146                     "download the appropriate data files from:\n"
    147                     "http://unicode.org/cldr/trac/browser/trunk/common/uca");
    148             }
    149         }
    150     }
    151 }
    152 
    153 static const uint32_t IS_SHIFTED = 1;
    154 static const uint32_t FROM_RULES = 2;
    155 
    156 static UBool
    157 skipLineBecauseOfBug(const UChar *s, int32_t length, uint32_t flags) {
    158     // Add temporary exceptions here if there are ICU bugs, until we can fix them.
    159     // For examples see the ICU 52 version of this file.
    160     (void)s;
    161     (void)length;
    162     (void)flags;
    163     return FALSE;
    164 }
    165 
    166 static UCollationResult
    167 normalizeResult(int32_t result) {
    168     return result<0 ? UCOL_LESS : result==0 ? UCOL_EQUAL : UCOL_GREATER;
    169 }
    170 
    171 void UCAConformanceTest::testConformance(const Collator *coll)
    172 {
    173     if(testFile == 0) {
    174         return;
    175     }
    176     uint32_t skipFlags = 0;
    177     if(coll->getAttribute(UCOL_ALTERNATE_HANDLING, status) == UCOL_SHIFTED) {
    178         skipFlags |= IS_SHIFTED;
    179     }
    180     if(coll == rbUCA) {
    181         skipFlags |= FROM_RULES;
    182     }
    183 
    184     logln("-prop:ucaconfnosortkeys=1 turns off getSortKey() in UCAConformanceTest");
    185     UBool withSortKeys = getProperty("ucaconfnosortkeys") == NULL;
    186 
    187     int32_t line = 0;
    188 
    189     UChar b1[1024], b2[1024];
    190     UChar *buffer = b1, *oldB = NULL;
    191 
    192     char lineB1[1024], lineB2[1024];
    193     char *lineB = lineB1, *oldLineB = lineB2;
    194 
    195     uint8_t sk1[1024], sk2[1024];
    196     uint8_t *oldSk = NULL, *newSk = sk1;
    197 
    198     int32_t oldLen = 0;
    199     int32_t oldBlen = 0;
    200     uint32_t first = 0;
    201 
    202     while (fgets(lineB, 1024, testFile) != NULL) {
    203         // remove trailing whitespace
    204         u_rtrim(lineB);
    205 
    206         line++;
    207         if(*lineB == 0 || lineB[0] == '#') {
    208             continue;
    209         }
    210         int32_t buflen = u_parseString(lineB, buffer, 1024, &first, &status);
    211         if(U_FAILURE(status)) {
    212             errln("Error parsing line %ld (%s): %s\n",
    213                   (long)line, u_errorName(status), lineB);
    214             status = U_ZERO_ERROR;
    215         }
    216         buffer[buflen] = 0;
    217 
    218         if(skipLineBecauseOfBug(buffer, buflen, skipFlags)) {
    219             logln("Skipping line %i because of a known bug", line);
    220             continue;
    221         }
    222 
    223         int32_t resLen = withSortKeys ? coll->getSortKey(buffer, buflen, newSk, 1024) : 0;
    224 
    225         if(oldSk != NULL) {
    226             UBool ok=TRUE;
    227             int32_t skres = withSortKeys ? strcmp((char *)oldSk, (char *)newSk) : 0;
    228             int32_t cmpres = coll->compare(oldB, oldBlen, buffer, buflen, status);
    229             int32_t cmpres2 = coll->compare(buffer, buflen, oldB, oldBlen, status);
    230 
    231             if(cmpres != -cmpres2) {
    232                 errln("Compare result not symmetrical on line %i: "
    233                       "previous vs. current (%d) / current vs. previous (%d)",
    234                       line, cmpres, cmpres2);
    235                 ok = FALSE;
    236             }
    237 
    238             // TODO: Compare with normalization turned off if the input passes the FCD test.
    239 
    240             if(withSortKeys && cmpres != normalizeResult(skres)) {
    241                 errln("Difference between coll->compare (%d) and sortkey compare (%d) on line %i",
    242                       cmpres, skres, line);
    243                 ok = FALSE;
    244             }
    245 
    246             int32_t res = cmpres;
    247             if(res == 0 && !isAtLeastUCA62) {
    248                 // Up to UCA 6.1, the collation test files use a custom tie-breaker,
    249                 // comparing the raw input strings.
    250                 res = u_strcmpCodePointOrder(oldB, buffer);
    251                 // Starting with UCA 6.2, the collation test files use the standard UCA tie-breaker,
    252                 // comparing the NFD versions of the input strings,
    253                 // which we do via setting strength=identical.
    254             }
    255             if(res > 0) {
    256                 errln("Line %i is not greater or equal than previous line", line);
    257                 ok = FALSE;
    258             }
    259 
    260             if(!ok) {
    261                 errln("  Previous data line %s", oldLineB);
    262                 errln("  Current data line  %s", lineB);
    263                 if(withSortKeys) {
    264                     UnicodeString oldS, newS;
    265                     prettify(CollationKey(oldSk, oldLen), oldS);
    266                     prettify(CollationKey(newSk, resLen), newS);
    267                     errln("  Previous key: "+oldS);
    268                     errln("  Current key:  "+newS);
    269                 }
    270             }
    271         }
    272 
    273         // swap buffers
    274         oldLineB = lineB;
    275         oldB = buffer;
    276         oldSk = newSk;
    277         if(lineB == lineB1) {
    278             lineB = lineB2;
    279             buffer = b2;
    280             newSk = sk2;
    281         } else {
    282             lineB = lineB1;
    283             buffer = b1;
    284             newSk = sk1;
    285         }
    286         oldLen = resLen;
    287         oldBlen = buflen;
    288     }
    289 }
    290 
    291 void UCAConformanceTest::TestTableNonIgnorable(/* par */) {
    292     if (U_FAILURE(status)) {
    293         dataerrln("Error running UCA Conformance Test: %s", u_errorName(status));
    294         return;
    295     }
    296     setCollNonIgnorable(UCA);
    297     openTestFile("NON_IGNORABLE");
    298     testConformance(UCA);
    299 }
    300 
    301 void UCAConformanceTest::TestTableShifted(/* par */) {
    302     if (U_FAILURE(status)) {
    303         dataerrln("Error running UCA Conformance Test: %s", u_errorName(status));
    304         return;
    305     }
    306     setCollShifted(UCA);
    307     openTestFile("SHIFTED");
    308     testConformance(UCA);
    309 }
    310 
    311 void UCAConformanceTest::TestRulesNonIgnorable(/* par */) {
    312     if(logKnownIssue("cldrbug:6745", "UCARules.txt has problems")) { return; }
    313     initRbUCA();
    314 
    315     if(U_SUCCESS(status)) {
    316         setCollNonIgnorable(rbUCA);
    317         openTestFile("NON_IGNORABLE");
    318         testConformance(rbUCA);
    319     }
    320 }
    321 
    322 void UCAConformanceTest::TestRulesShifted(/* par */) {
    323     logln("This test is currently disabled, as it is impossible to "
    324         "wholly represent fractional UCA using tailoring rules.");
    325     return;
    326 
    327     initRbUCA();
    328 
    329     if(U_SUCCESS(status)) {
    330         setCollShifted(rbUCA);
    331         openTestFile("SHIFTED");
    332         testConformance(rbUCA);
    333     }
    334 }
    335 
    336 #endif /* #if !UCONFIG_NO_COLLATION */
    337