Update ICU to 54.1 step 1

source/test/cintltst/callcoll.c

 /********************************************************************
  * COPYRIGHT: 
- * Copyright (c) 1997-2013, International Business Machines Corporation and
+ * Copyright (c) 1997-2014, International Business Machines Corporation and
  * others. All Rights Reserved.
  ********************************************************************/
 /*******************************************************************************
 *
 * File CALLCOLL.C
 *
 * Modification History:
 *        Name                     Description            
 *     Madhu Katragadda              Ported for C API
 ********************************************************************************
@@ skipping 991 matching lines @@
 
 
 
 /**
 * Tests the [variable top] tag in rule syntax. Since the default [alternate]
 * tag has the value shifted, any codepoints before [variable top] should give
 * a primary ce of 0.
 */
 static void TestVariableTop(void)
 {
+#if 0
+    /*
+     * Starting with ICU 53, setting the variable top via a pseudo relation string
+     * is not supported any more.
+     * It was replaced by the [maxVariable symbol] setting.
+     * See ICU tickets #9958 and #8032.
+     */
     static const char       str[]          = "&z = [variable top]";
           int         len          = strlen(str);
           UChar      rules[sizeof(str)];
           UCollator  *myCollation;
           UCollator  *enCollation;
           UErrorCode  status       = U_ZERO_ERROR;
           UChar       source[1];
           UChar       ch;
           uint8_t     result[20];
           uint8_t     expected[20];
@@ skipping 46 matching lines @@
             log_err("ERROR: SHIFTED alternate does not return 0 for primary of %c\n", 
                     ch);
         }
         ch ++;
     }
   
     ucol_close(enCollation);
     ucol_close(myCollation);
     enCollation = NULL;
     myCollation = NULL;
+#endif
 }
 
 /**
   * Tests surrogate support.
   * NOTE: This test used \\uD801\\uDC01 pair, which is now assigned to Desseret
   * Therefore, another (unassigned) code point was used for this test.
   */
 static void TestSurrogates(void)
 {
     static const char       str[]          = 
@@ skipping 69 matching lines @@
  */
 static void 
 TestInvalidRules(){
 #define MAX_ERROR_STATES 2
 
     static const char* rulesArr[MAX_ERROR_STATES] = {
         "& C < ch, cH, Ch[this should fail]<d",
         "& C < ch, cH, & Ch[variable top]"
     };
     static const char* preContextArr[MAX_ERROR_STATES] = {
-        "his should fail",
-        "& C < ch, cH, ",
+        " C < ch, cH, Ch",
+        "& C < ch, cH",
 
     };
     static const char* postContextArr[MAX_ERROR_STATES] = {
-        "<d",
-        " Ch[variable t"
+        "[this should fa",
+        ", & Ch[variable"
     };
     int i;
 
     for(i = 0;i<MAX_ERROR_STATES;i++){
         UChar rules[1000]       = { '\0' };
         UChar preContextExp[1000]  = { '\0' };
         UChar postContextExp[1000] = { '\0' };
         UParseError parseError;
         UErrorCode status = U_ZERO_ERROR;
         UCollator* coll=0;
         u_charsToUChars(rulesArr[i],rules,uprv_strlen(rulesArr[i])+1);
         u_charsToUChars(preContextArr[i],preContextExp,uprv_strlen(preContextArr[i])+1);
         u_charsToUChars(postContextArr[i],postContextExp,uprv_strlen(postContextArr[i])+1);
         /* clean up stuff in parseError */
         u_memset(parseError.preContext,0x0000,U_PARSE_CONTEXT_LEN);      
         u_memset(parseError.postContext,0x0000,U_PARSE_CONTEXT_LEN);
         /* open the rules and test */
         coll = ucol_openRules(rules,u_strlen(rules),UCOL_OFF,UCOL_DEFAULT_STRENGTH,&parseError,&status);
         (void)coll;   /* Suppress set but not used warning. */
         if(u_strcmp(parseError.preContext,preContextExp)!=0){
-            log_err_status(status, "preContext in UParseError for ucol_openRules does not match\n");
+            log_err_status(status, "preContext in UParseError for ucol_openRules does not match: \"%s\"\n",
+                           aescstrdup(parseError.preContext, -1));
         }
         if(u_strcmp(parseError.postContext,postContextExp)!=0){
-            log_err_status(status, "postContext in UParseError for ucol_openRules does not match\n");
+            log_err_status(status, "postContext in UParseError for ucol_openRules does not match: \"%s\"\n",
+                           aescstrdup(parseError.postContext, -1));
         }
     }  
 }
 
 static void
 TestJitterbug1098(){
     UChar rule[1000];
     UCollator* c1 = NULL;
     UErrorCode status = U_ZERO_ERROR;
     UParseError parseError;
     char preContext[200]={0};
     char postContext[200]={0};
     int i=0;
     const char* rules[] = {
          "&''<\\\\",
          "&\\'<\\\\",
          "&\\\"<'\\'",
          "&'\"'<\\'",
-         '\0'
+         NULL
 
     };
     const UCollationResult results1098[] = {
         UCOL_LESS,
         UCOL_LESS, 
         UCOL_LESS,
         UCOL_LESS,
     };
     const UChar input[][2]= {
         {0x0027,0x005c},
@@ skipping 71 matching lines @@
 static void TestJ5298(void)
 {
     UErrorCode status = U_ZERO_ERROR;
     char input[256], output[256];
     UBool isAvailable;
     int32_t i = 0;
     UEnumeration* values = NULL;
     const char *keywordValue = NULL;
     log_verbose("Number of collator locales returned : %i \n", ucol_countAvailable());
     values = ucol_getKeywordValues("collation", &status);
+    while ((keywordValue = uenum_next(values, NULL, &status)) != NULL) {
+        if (strncmp(keywordValue, "private-", 8) == 0) {
+            log_err("ucol_getKeywordValues() returns private collation keyword: %s\n", keywordValue);
+        }
+    }
     for (i = 0; i < ucol_countAvailable(); i++) {
         uenum_reset(values, &status);
         while ((keywordValue = uenum_next(values, NULL, &status)) != NULL) {
             strcpy(input, ucol_getAvailable(i));
             if (strcmp(keywordValue, "standard") != 0) {
                 strcat(input, "@collation=");
                 strcat(input, keywordValue);
             }
 
             ucol_getFunctionalEquivalent(output, 256, "collation", input, &isAvailable, &status);
             if (strcmp(input, output) == 0) { /* Unique locale, print it out */
                 log_verbose("%s, \n", output);
             }
         }
     }
     uenum_close(values);
     log_verbose("\n");
 }
 #endif /* #if !UCONFIG_NO_COLLATION */