X-Git-Url: https://git.saurik.com/apple/icu.git/blobdiff_plain/46f4442e9a5a4f3b98b7c1083586332f6a8a99a4..a0b4f637ba1a6c3c5651b61a69303b029bacf7d3:/icuSources/test/intltest/ucaconf.cpp

diff --git a/icuSources/test/intltest/ucaconf.cpp b/icuSources/test/intltest/ucaconf.cpp
index bc85d90c..348415a3 100644
--- a/icuSources/test/intltest/ucaconf.cpp
+++ b/icuSources/test/intltest/ucaconf.cpp
@@ -1,6 +1,6 @@
 /********************************************************************
- * COPYRIGHT: 
- * Copyright (c) 2002-2008, International Business Machines Corporation and
+ * COPYRIGHT:
+ * Copyright (c) 2002-2014, International Business Machines Corporation and
  * others. All Rights Reserved.
  ********************************************************************/
 
@@ -15,7 +15,10 @@
 #if !UCONFIG_NO_COLLATION
 
 #include "ucaconf.h"
+#include "unicode/sortkey.h"
+#include "unicode/tblcoll.h"
 #include "unicode/ustring.h"
+#include "cmemory.h"
 #include "cstring.h"
 #include "uparse.h"
 
@@ -24,83 +27,81 @@ rbUCA(NULL),
 testFile(NULL),
 status(U_ZERO_ERROR)
 {
-    UCA = ucol_open("root", &status);
+    UCA = (RuleBasedCollator *)Collator::createInstance(Locale::getRoot(), status);
     if(U_FAILURE(status)) {
-        errln("ERROR - UCAConformanceTest: Unable to open UCA collator!");
+        dataerrln("Error - UCAConformanceTest: Unable to open UCA collator! - %s", u_errorName(status));
     }
 
     const char *srcDir = IntlTest::getSourceTestData(status);
     if (U_FAILURE(status)) {
-        dataerrln("[DATA] Could not open test data %s", u_errorName(status));
+        dataerrln("Could not open test data %s", u_errorName(status));
         return;
     }
     uprv_strcpy(testDataPath, srcDir);
     uprv_strcat(testDataPath, "CollationTest_");
+
+    UVersionInfo uniVersion;
+    static const UVersionInfo v62 = { 6, 2, 0, 0 };
+    u_getUnicodeVersion(uniVersion);
+    isAtLeastUCA62 = uprv_memcmp(uniVersion, v62, 4) >= 0;
 }
 
 UCAConformanceTest::~UCAConformanceTest()
 {
-    ucol_close(UCA);
-    if(rbUCA) {
-        ucol_close(rbUCA);
-    }
-    if(testFile) {
+    delete UCA;
+    delete rbUCA;
+    if (testFile) {
         fclose(testFile);
     }
 }
 
 void UCAConformanceTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par */)
 {
-    if (exec) logln("TestSuite UCAConformanceTest: ");
-    if(U_SUCCESS(status)) {
-      switch (index) {
-          case 0: name = "TestTableNonIgnorable"; if (exec)   TestTableNonIgnorable(/* par */); break;
-          case 1: name = "TestTableShifted";      if (exec)   TestTableShifted(/* par */);      break;
-          case 2: name = "TestRulesNonIgnorable"; if (exec)   TestRulesNonIgnorable(/* par */); break;
-          case 3: name = "TestRulesShifted";      if (exec)   TestRulesShifted(/* par */);      break;
-          default: name = ""; break;
-      }
-    } else {
-      name = "";
+    if(exec) {
+        logln("TestSuite UCAConformanceTest: ");
     }
+    TESTCASE_AUTO_BEGIN;
+    TESTCASE_AUTO(TestTableNonIgnorable);
+    TESTCASE_AUTO(TestTableShifted);
+    TESTCASE_AUTO(TestRulesNonIgnorable);
+    TESTCASE_AUTO(TestRulesShifted);
+    TESTCASE_AUTO_END;
 }
 
 void UCAConformanceTest::initRbUCA() 
 {
     if(!rbUCA) {
-        UParseError parseError;
-        UChar      *ucarules;
-        // preflight rules
-        int32_t size = ucol_getRulesEx(UCA, UCOL_FULL_RULES, NULL, 0);
-        ucarules = (UChar *)malloc(size * sizeof(UChar));
-
-        size = ucol_getRulesEx(UCA, UCOL_FULL_RULES, ucarules, size);
-        rbUCA = ucol_openRules(ucarules, size, UCOL_DEFAULT, UCOL_TERTIARY, 
-            &parseError, &status);
-        free(ucarules);
-        if (U_FAILURE(status)) {
-            errln("Failure creating UCA rule-based collator: %s", u_errorName(status));
+        if (UCA) {
+            UnicodeString ucarules;
+            UCA->getRules(UCOL_FULL_RULES, ucarules);
+            rbUCA = new RuleBasedCollator(ucarules, status);
+            if (U_FAILURE(status)) {
+                dataerrln("Failure creating UCA rule-based collator: %s", u_errorName(status));
+                return;
+            }
+        } else {
+            dataerrln("Failure creating UCA rule-based collator: %s", u_errorName(status));
             return;
         }
     }
 }
 
-void UCAConformanceTest::setCollNonIgnorable(UCollator *coll) 
+void UCAConformanceTest::setCollNonIgnorable(Collator *coll) 
 {
-  ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
-  ucol_setAttribute(coll, UCOL_CASE_FIRST, UCOL_OFF, &status);
-  ucol_setAttribute(coll, UCOL_CASE_LEVEL, UCOL_OFF, &status);
-  ucol_setAttribute(coll, UCOL_STRENGTH, UCOL_TERTIARY, &status);
-  ucol_setAttribute(coll, UCOL_ALTERNATE_HANDLING, UCOL_NON_IGNORABLE, &status);
+    coll->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
+    coll->setAttribute(UCOL_CASE_FIRST, UCOL_OFF, status);
+    coll->setAttribute(UCOL_CASE_LEVEL, UCOL_OFF, status);
+    coll->setAttribute(UCOL_STRENGTH, isAtLeastUCA62 ? UCOL_IDENTICAL : UCOL_TERTIARY, status);
+    coll->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_NON_IGNORABLE, status);
 }
 
-void UCAConformanceTest::setCollShifted(UCollator *coll) 
+void UCAConformanceTest::setCollShifted(Collator *coll) 
 {
-    ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
-    ucol_setAttribute(coll, UCOL_CASE_FIRST, UCOL_OFF, &status);
-    ucol_setAttribute(coll, UCOL_CASE_LEVEL, UCOL_OFF, &status);
-    ucol_setAttribute(coll, UCOL_STRENGTH, UCOL_QUATERNARY, &status);
-    ucol_setAttribute(coll, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, &status);
+    coll->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
+    coll->setAttribute(UCOL_CASE_FIRST, UCOL_OFF, status);
+    coll->setAttribute(UCOL_CASE_LEVEL, UCOL_OFF, status);
+    coll->setAttribute(UCOL_STRENGTH, isAtLeastUCA62 ? UCOL_IDENTICAL : UCOL_QUATERNARY, status);
+    coll->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, status);
 }
 
 void UCAConformanceTest::openTestFile(const char *type)
@@ -136,109 +137,179 @@ void UCAConformanceTest::openTestFile(const char *type)
 
             if (testFile == 0) {
                 *(buffer+bufLen) = 0;
-                dataerrln("[DATA] Could not open any of the conformance test files, tried opening base %s\n", buffer);
+                dataerrln("Could not open any of the conformance test files, tried opening base %s\n", buffer);
                 return;        
             } else {
                 infoln(
                     "INFO: Working with the stub file.\n"
                     "If you need the full conformance test, please\n"
                     "download the appropriate data files from:\n"
-                    "http://source.icu-project.org/repos/icu/tools/trunk/unicodetools/com/ibm/text/data/");
+                    "http://unicode.org/cldr/trac/browser/trunk/common/uca");
             }
         }
     }
 }
 
-void UCAConformanceTest::testConformance(UCollator *coll) 
+static const uint32_t IS_SHIFTED = 1;
+static const uint32_t FROM_RULES = 2;
+
+static UBool
+skipLineBecauseOfBug(const UChar *s, int32_t length, uint32_t flags) {
+    // Add temporary exceptions here if there are ICU bugs, until we can fix them.
+    // For examples see the ICU 52 version of this file.
+    (void)s;
+    (void)length;
+    (void)flags;
+    return FALSE;
+}
+
+static UCollationResult
+normalizeResult(int32_t result) {
+    return result<0 ? UCOL_LESS : result==0 ? UCOL_EQUAL : UCOL_GREATER;
+}
+
+void UCAConformanceTest::testConformance(const Collator *coll) 
 {
     if(testFile == 0) {
         return;
     }
+    uint32_t skipFlags = 0;
+    if(coll->getAttribute(UCOL_ALTERNATE_HANDLING, status) == UCOL_SHIFTED) {
+        skipFlags |= IS_SHIFTED;
+    }
+    if(coll == rbUCA) {
+        skipFlags |= FROM_RULES;
+    }
+
+    logln("-prop:ucaconfnosortkeys=1 turns off getSortKey() in UCAConformanceTest");
+    UBool withSortKeys = getProperty("ucaconfnosortkeys") == NULL;
 
     int32_t line = 0;
 
     UChar b1[1024], b2[1024];
-    char lineB[1024];
     UChar *buffer = b1, *oldB = NULL;
+
+    char lineB1[1024], lineB2[1024];
+    char *lineB = lineB1, *oldLineB = lineB2;
+
     uint8_t sk1[1024], sk2[1024];
     uint8_t *oldSk = NULL, *newSk = sk1;
-    int32_t resLen = 0, oldLen = 0;
-    int32_t buflen = 0, oldBlen = 0;
-    uint32_t first = 0;
-    uint32_t offset = 0;
-    UnicodeString oldS, newS;
 
+    int32_t oldLen = 0;
+    int32_t oldBlen = 0;
+    uint32_t first = 0;
 
     while (fgets(lineB, 1024, testFile) != NULL) {
-        offset = 0;
+        // remove trailing whitespace
+        u_rtrim(lineB);
 
         line++;
-        if(*lineB == 0 || strlen(lineB) < 3 || lineB[0] == '#') {
+        if(*lineB == 0 || lineB[0] == '#') {
             continue;
         }
-        offset = u_parseString(lineB, buffer, 1024, &first, &status);
-        buflen = offset;
-        buffer[offset++] = 0;
+        int32_t buflen = u_parseString(lineB, buffer, 1024, &first, &status);
+        if(U_FAILURE(status)) {
+            errln("Error parsing line %ld (%s): %s\n",
+                  (long)line, u_errorName(status), lineB);
+            status = U_ZERO_ERROR;
+        }
+        buffer[buflen] = 0;
 
-        resLen = ucol_getSortKey(coll, buffer, buflen, newSk, 1024);
+        if(skipLineBecauseOfBug(buffer, buflen, skipFlags)) {
+            logln("Skipping line %i because of a known bug", line);
+            continue;
+        }
 
-        int32_t res = 0, cmpres = 0, cmpres2 = 0;
+        int32_t resLen = withSortKeys ? coll->getSortKey(buffer, buflen, newSk, 1024) : 0;
 
         if(oldSk != NULL) {
-            res = strcmp((char *)oldSk, (char *)newSk);
-            cmpres = ucol_strcoll(coll, oldB, oldBlen, buffer, buflen);
-            cmpres2 = ucol_strcoll(coll, buffer, buflen, oldB, oldBlen);
+            UBool ok=TRUE;
+            int32_t skres = withSortKeys ? strcmp((char *)oldSk, (char *)newSk) : 0;
+            int32_t cmpres = coll->compare(oldB, oldBlen, buffer, buflen, status);
+            int32_t cmpres2 = coll->compare(buffer, buflen, oldB, oldBlen, status);
 
             if(cmpres != -cmpres2) {
-                errln("Compare result not symmetrical on line %i", line);
+                errln("Compare result not symmetrical on line %i: "
+                      "previous vs. current (%d) / current vs. previous (%d)",
+                      line, cmpres, cmpres2);
+                ok = FALSE;
             }
 
-            if(((res&0x80000000) != (cmpres&0x80000000)) || (res == 0 && cmpres != 0) || (res != 0 && cmpres == 0)) {
-                errln("Difference between ucol_strcoll and sortkey compare on line %i", line);
-                logln("Data line %s", lineB);
+            // TODO: Compare with normalization turned off if the input passes the FCD test.
+
+            if(withSortKeys && cmpres != normalizeResult(skres)) {
+                errln("Difference between coll->compare (%d) and sortkey compare (%d) on line %i",
+                      cmpres, skres, line);
+                ok = FALSE;
             }
 
+            int32_t res = cmpres;
+            if(res == 0 && !isAtLeastUCA62) {
+                // Up to UCA 6.1, the collation test files use a custom tie-breaker,
+                // comparing the raw input strings.
+                res = u_strcmpCodePointOrder(oldB, buffer);
+                // Starting with UCA 6.2, the collation test files use the standard UCA tie-breaker,
+                // comparing the NFD versions of the input strings,
+                // which we do via setting strength=identical.
+            }
             if(res > 0) {
                 errln("Line %i is not greater or equal than previous line", line);
-                logln("Data line %s", lineB);
-                prettify(CollationKey(oldSk, oldLen), oldS);
-                prettify(CollationKey(newSk, resLen), newS);
-                logln("Keys: "+oldS+" and "+newS);
-            } else if(res == 0) { /* equal */
-                res = u_strcmpCodePointOrder(oldB, buffer);
-                if (res == 0) {
-                    errln("Probable error in test file on line %i (comparing identical strings)", line);
-                    logln("Data line %s", lineB);
-                } else if (res > 0) {
-                    errln("Sortkeys are identical, but code point comapare gives >0 on line %i", line);
-                    logln("Data line %s", lineB);
+                ok = FALSE;
+            }
+
+            if(!ok) {
+                errln("  Previous data line %s", oldLineB);
+                errln("  Current data line  %s", lineB);
+                if(withSortKeys) {
+                    UnicodeString oldS, newS;
+                    prettify(CollationKey(oldSk, oldLen), oldS);
+                    prettify(CollationKey(newSk, resLen), newS);
+                    errln("  Previous key: "+oldS);
+                    errln("  Current key:  "+newS);
                 }
             }
         }
 
+        // swap buffers
+        oldLineB = lineB;
+        oldB = buffer;
         oldSk = newSk;
+        if(lineB == lineB1) {
+            lineB = lineB2;
+            buffer = b2;
+            newSk = sk2;
+        } else {
+            lineB = lineB1;
+            buffer = b1;
+            newSk = sk1;
+        }
         oldLen = resLen;
-
-        newSk = (newSk == sk1)?sk2:sk1;
-        oldB = buffer;
         oldBlen = buflen;
-        buffer = (buffer == b1)?b2:b1;
     }
 }
 
 void UCAConformanceTest::TestTableNonIgnorable(/* par */) {
+    if (U_FAILURE(status)) {
+        dataerrln("Error running UCA Conformance Test: %s", u_errorName(status));
+        return;
+    }
     setCollNonIgnorable(UCA);
     openTestFile("NON_IGNORABLE");
     testConformance(UCA);
 }
 
 void UCAConformanceTest::TestTableShifted(/* par */) {
+    if (U_FAILURE(status)) {
+        dataerrln("Error running UCA Conformance Test: %s", u_errorName(status));
+        return;
+    }
     setCollShifted(UCA);
     openTestFile("SHIFTED");
     testConformance(UCA);
 }
 
 void UCAConformanceTest::TestRulesNonIgnorable(/* par */) {
+    if(logKnownIssue("cldrbug:6745", "UCARules.txt has problems")) { return; }
     initRbUCA();
 
     if(U_SUCCESS(status)) {