Update ICU to 54.1 step 1

source/test/intltest/ucaconf.cpp

 /********************************************************************
  * COPYRIGHT:
- * Copyright (c) 2002-2012, International Business Machines Corporation and
+ * Copyright (c) 2002-2014, International Business Machines Corporation and
  * others. All Rights Reserved.
  ********************************************************************/
 
 /**
  * UCAConformanceTest performs conformance tests defined in the data
  * files. ICU ships with stub data files, as the whole test are too 
  * long. To do the whole test, download the test files.
  */
 
 #include "unicode/utypes.h"
 
 #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"
 
 UCAConformanceTest::UCAConformanceTest() :
 rbUCA(NULL),
 testFile(NULL),
 status(U_ZERO_ERROR)
 {
@@ skipping 34 matching lines @@
     TESTCASE_AUTO(TestTableNonIgnorable);
     TESTCASE_AUTO(TestTableShifted);
     TESTCASE_AUTO(TestRulesNonIgnorable);
     TESTCASE_AUTO(TestRulesShifted);
     TESTCASE_AUTO_END;
 }
 
 void UCAConformanceTest::initRbUCA() 
 {
     if(!rbUCA) {
-        UnicodeString ucarules;
         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;
         }
@@ skipping 51 matching lines @@
 
             if (testFile == 0) {
                 *(buffer+bufLen) = 0;
                 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");
             }
         }
     }
 }
 
 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) {
-    // TODO: Fix ICU ticket #8052
-    if(length >= 3 &&
-            (s[0] == 0xfb2 || s[0] == 0xfb3) &&
-            s[1] == 0x334 &&
-            (s[2] == 0xf73 || s[2] == 0xf75 || s[2] == 0xf81)) {
-        return TRUE;
-    }
-    // TODO: Fix ICU ticket #9361
-    if((flags & IS_SHIFTED) != 0 && length >= 2 && s[0] == 0xfffe) {
-        return TRUE;
-    }
-    // TODO: Fix tailoring builder, ICU ticket #9593.
-    UChar c;
-    if((flags & FROM_RULES) != 0 && length >= 2 && ((c = s[1]) == 0xedc || c == 0xedd)) {
-        return TRUE;
-    }
+    // 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];
     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;
@@ skipping 16 matching lines @@
                   (long)line, u_errorName(status), lineB);
             status = U_ZERO_ERROR;
         }
         buffer[buflen] = 0;
 
         if(skipLineBecauseOfBug(buffer, buflen, skipFlags)) {
             logln("Skipping line %i because of a known bug", line);
             continue;
         }
 
-        int32_t resLen = coll->getSortKey(buffer, buflen, newSk, 1024);
+        int32_t resLen = withSortKeys ? coll->getSortKey(buffer, buflen, newSk, 1024) : 0;
 
         if(oldSk != NULL) {
-            int32_t skres = strcmp((char *)oldSk, (char *)newSk);
+            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(cmpres != normalizeResult(skres)) {
+            // 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);
-                errln("  Previous data line %s", oldLineB);
-                errln("  Current data line  %s", lineB);
+                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);
+                ok = FALSE;
+            }
+
+            if(!ok) {
                 errln("  Previous data line %s", oldLineB);
                 errln("  Current data line  %s", lineB);
-                UnicodeString oldS, newS;
-                prettify(CollationKey(oldSk, oldLen), oldS);
-                prettify(CollationKey(newSk, resLen), newS);
-                errln("  Previous key: "+oldS);
-                errln("  Current key:  "+newS);
+                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;
@@ skipping 22 matching lines @@
     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)) {
         setCollNonIgnorable(rbUCA);
         openTestFile("NON_IGNORABLE");
         testConformance(rbUCA);
     }
 }
 
 void UCAConformanceTest::TestRulesShifted(/* par */) {
     logln("This test is currently disabled, as it is impossible to "
         "wholly represent fractional UCA using tailoring rules.");
     return;
 
     initRbUCA();
 
     if(U_SUCCESS(status)) {
         setCollShifted(rbUCA);
         openTestFile("SHIFTED");
         testConformance(rbUCA);
     }
 }
 
 #endif /* #if !UCONFIG_NO_COLLATION */