icuSources/test/cintltst/callcoll.c

   1 /********************************************************************
   2  * COPYRIGHT:
   3  * Copyright (c) 1997-2014, International Business Machines Corporation and
   4  * others. All Rights Reserved.
   5  ********************************************************************/
   6 /*******************************************************************************
   7 *
   8 * File CALLCOLL.C
   9 *
  10 * Modification History:
  11 *        Name                     Description
  12 *     Madhu Katragadda              Ported for C API
  13 ********************************************************************************
  14 */
  15
  16 /*
  17  * Important: This file is included into intltest/allcoll.cpp so that the
  18  * test data is shared. This makes it easier to maintain the test data,
  19  * especially since the Unicode data must be portable and quoted character
  20  * literals will not work.
  21  * If it is included, then there will be a #define INCLUDE_CALLCOLL_C
  22  * that must prevent the actual code in here from being part of the
  23  * allcoll.cpp compilation.
  24  */
  25
  26 /**
  27  * CollationDummyTest is a third level test class.  This tests creation of
  28  * a customized collator object.  For example, number 1 to be sorted
  29  * equlivalent to word 'one'.
  30  */
  31
  32 #include <string.h>
  33 #include <stdlib.h>
  34
  35 #include "unicode/utypes.h"
  36
  37 #if !UCONFIG_NO_COLLATION
  38
  39 #include "unicode/ucol.h"
  40 #include "unicode/uloc.h"
  41 #include "unicode/ures.h"
  42 #include "unicode/udata.h"
  43 #include "unicode/ucoleitr.h"
  44 #include "unicode/ustring.h"
  45 #include "unicode/uclean.h"
  46 #include "unicode/putil.h"
  47 #include "unicode/uenum.h"
  48
  49 #include "cintltst.h"
  50 #include "ccolltst.h"
  51 #include "callcoll.h"
  52 #include "calldata.h"
  53 #include "cstring.h"
  54 #include "cmemory.h"
  55
  56 /* set to 1 to test offsets in backAndForth() */
  57 #define TEST_OFFSETS 0
  58
  59 /* perform test with strength PRIMARY */
  60 static void TestPrimary(void);
  61
  62 /* perform test with strength SECONDARY */
  63 static void TestSecondary(void);
  64
  65 /* perform test with strength tertiary */
  66 static void TestTertiary(void);
  67
  68 /*perform tests with strength Identical */
  69 static void TestIdentical(void);
  70
  71 /* perform extra tests */
  72 static void TestExtra(void);
  73
  74 /* Test jitterbug 581 */
  75 static void TestJB581(void);
  76
  77 /* Test jitterbug 1401 */
  78 static void TestJB1401(void);
  79
  80 /* Test [variable top] in the rule syntax */
  81 static void TestVariableTop(void);
  82
  83 /* Test surrogates */
  84 static void TestSurrogates(void);
  85
  86 static void TestInvalidRules(void);
  87
  88 static void TestJitterbug1098(void);
  89
  90 static void TestFCDCrash(void);
  91
  92 static void TestJ5298(void);
  93
  94 const UCollationResult results[] = {
  95     UCOL_LESS,
  96     UCOL_LESS, /*UCOL_GREATER,*/
  97     UCOL_LESS,
  98     UCOL_LESS,
  99     UCOL_LESS,
 100     UCOL_LESS,
 101     UCOL_LESS,
 102     UCOL_GREATER,
 103     UCOL_GREATER,
 104     UCOL_LESS,                                     /*  10 */
 105     UCOL_GREATER,
 106     UCOL_LESS,
 107     UCOL_GREATER,
 108     UCOL_GREATER,
 109     UCOL_LESS,
 110     UCOL_LESS,
 111     UCOL_LESS,
 112     /*  test primary > 17 */
 113     UCOL_EQUAL,
 114     UCOL_EQUAL,
 115     UCOL_EQUAL,                                    /*  20 */
 116     UCOL_LESS,
 117     UCOL_LESS,
 118     UCOL_EQUAL,
 119     UCOL_EQUAL,
 120     UCOL_EQUAL,
 121     UCOL_LESS,
 122     /*  test secondary > 26 */
 123     UCOL_EQUAL,
 124     UCOL_EQUAL,
 125     UCOL_EQUAL,
 126     UCOL_EQUAL,
 127     UCOL_EQUAL,                                    /*  30 */
 128     UCOL_EQUAL,
 129     UCOL_LESS,
 130     UCOL_EQUAL,                                     /*  34 */
 131     UCOL_EQUAL,
 132     UCOL_EQUAL,
 133     UCOL_LESS                                        /* 37 */
 134 };
 135
 136
 137 static
 138 void uprv_appendByteToHexString(char *dst, uint8_t val) {
 139   uint32_t len = (uint32_t)uprv_strlen(dst);
 140   *(dst+len) = T_CString_itosOffset((val >> 4));
 141   *(dst+len+1) = T_CString_itosOffset((val & 0xF));
 142   *(dst+len+2) = 0;
 143 }
 144
 145 /* this function makes a string with representation of a sortkey */
 146 static char* U_EXPORT2 sortKeyToString(const UCollator *coll, const uint8_t *sortkey, char *buffer, uint32_t *len) {
 147     int32_t strength = UCOL_PRIMARY;
 148     uint32_t res_size = 0;
 149     UBool doneCase = FALSE;
 150     UErrorCode errorCode = U_ZERO_ERROR;
 151
 152     char *current = buffer;
 153     const uint8_t *currentSk = sortkey;
 154
 155     uprv_strcpy(current, "[");
 156
 157     while(strength <= UCOL_QUATERNARY && strength <= ucol_getStrength(coll)) {
 158         if(strength > UCOL_PRIMARY) {
 159             uprv_strcat(current, " . ");
 160         }
 161         while(*currentSk != 0x01 && *currentSk != 0x00) { /* print a level */
 162             uprv_appendByteToHexString(current, *currentSk++);
 163             uprv_strcat(current, " ");
 164         }
 165         if(ucol_getAttribute(coll, UCOL_CASE_LEVEL, &errorCode) == UCOL_ON && strength == UCOL_SECONDARY && doneCase == FALSE) {
 166             doneCase = TRUE;
 167         } else if(ucol_getAttribute(coll, UCOL_CASE_LEVEL, &errorCode) == UCOL_OFF || doneCase == TRUE || strength != UCOL_SECONDARY) {
 168             strength ++;
 169         }
 170         if (*currentSk) {
 171             uprv_appendByteToHexString(current, *currentSk++); /* This should print '01' */
 172         }
 173         if(strength == UCOL_QUATERNARY && ucol_getAttribute(coll, UCOL_ALTERNATE_HANDLING, &errorCode) == UCOL_NON_IGNORABLE) {
 174             break;
 175         }
 176     }
 177
 178     if(ucol_getStrength(coll) == UCOL_IDENTICAL) {
 179         uprv_strcat(current, " . ");
 180         while(*currentSk != 0) {
 181             uprv_appendByteToHexString(current, *currentSk++);
 182             uprv_strcat(current, " ");
 183         }
 184
 185         uprv_appendByteToHexString(current, *currentSk++);
 186     }
 187     uprv_strcat(current, "]");
 188
 189     if(res_size > *len) {
 190         return NULL;
 191     }
 192
 193     return buffer;
 194 }
 195
 196 void addAllCollTest(TestNode** root)
 197 {
 198     addTest(root, &TestPrimary, "tscoll/callcoll/TestPrimary");
 199     addTest(root, &TestSecondary, "tscoll/callcoll/TestSecondary");
 200     addTest(root, &TestTertiary, "tscoll/callcoll/TestTertiary");
 201     addTest(root, &TestIdentical, "tscoll/callcoll/TestIdentical");
 202     addTest(root, &TestExtra, "tscoll/callcoll/TestExtra");
 203     addTest(root, &TestJB581, "tscoll/callcoll/TestJB581");
 204     addTest(root, &TestVariableTop, "tscoll/callcoll/TestVariableTop");
 205     addTest(root, &TestSurrogates, "tscoll/callcoll/TestSurrogates");
 206     addTest(root, &TestInvalidRules, "tscoll/callcoll/TestInvalidRules");
 207     addTest(root, &TestJB1401, "tscoll/callcoll/TestJB1401");
 208     addTest(root, &TestJitterbug1098, "tscoll/callcoll/TestJitterbug1098");
 209     addTest(root, &TestFCDCrash, "tscoll/callcoll/TestFCDCrash");
 210     addTest(root, &TestJ5298, "tscoll/callcoll/TestJ5298");
 211 }
 212
 213 UBool hasCollationElements(const char *locName) {
 214
 215   UErrorCode status = U_ZERO_ERROR;
 216
 217   UResourceBundle *loc = ures_open(U_ICUDATA_NAME U_TREE_SEPARATOR_STRING "coll", locName, &status);;
 218
 219   if(U_SUCCESS(status)) {
 220     status = U_ZERO_ERROR;
 221     loc = ures_getByKey(loc, "collations", loc, &status);
 222     ures_close(loc);
 223     if(status == U_ZERO_ERROR) { /* do the test - there are real elements */
 224       return TRUE;
 225     }
 226   }
 227   return FALSE;
 228 }
 229
 230 static UCollationResult compareUsingPartials(UCollator *coll, const UChar source[], int32_t sLen, const UChar target[], int32_t tLen, int32_t pieceSize, UErrorCode *status) {
 231   int32_t partialSKResult = 0;
 232   UCharIterator sIter, tIter;
 233   uint32_t sState[2], tState[2];
 234   int32_t sSize = pieceSize, tSize = pieceSize;
 235   /*int32_t i = 0;*/
 236   uint8_t sBuf[16384], tBuf[16384];
 237   if(pieceSize > 16384) {
 238     log_err("Partial sortkey size buffer too small. Please consider increasing the buffer!\n");
 239     *status = U_BUFFER_OVERFLOW_ERROR;
 240     return UCOL_EQUAL;
 241   }
 242   *status = U_ZERO_ERROR;
 243   sState[0] = 0; sState[1] = 0;
 244   tState[0] = 0; tState[1] = 0;
 245   while(sSize == pieceSize && tSize == pieceSize && partialSKResult == 0) {
 246     uiter_setString(&sIter, source, sLen);
 247     uiter_setString(&tIter, target, tLen);
 248     sSize = ucol_nextSortKeyPart(coll, &sIter, sState, sBuf, pieceSize, status);
 249     tSize = ucol_nextSortKeyPart(coll, &tIter, tState, tBuf, pieceSize, status);
 250
 251     if(sState[0] != 0 || tState[0] != 0) {
 252       /*log_verbose("State != 0 : %08X %08X\n", sState[0], tState[0]);*/
 253     }
 254     /*log_verbose("%i ", i++);*/
 255
 256     partialSKResult = memcmp(sBuf, tBuf, pieceSize);
 257   }
 258
 259   if(partialSKResult < 0) {
 260       return UCOL_LESS;
 261   } else if(partialSKResult > 0) {
 262     return UCOL_GREATER;
 263   } else {
 264     return UCOL_EQUAL;
 265   }
 266 }
 267
 268 static void doTestVariant(UCollator* myCollation, const UChar source[], const UChar target[], UCollationResult result)
 269 {
 270     int32_t sortklen1, sortklen2, sortklenmax, sortklenmin;
 271     int temp=0, gSortklen1=0,gSortklen2=0;
 272     UCollationResult compareResult, compareResulta, keyResult, compareResultIter = result;
 273     uint8_t *sortKey1, *sortKey2, *sortKey1a, *sortKey2a;
 274     uint32_t sLen = u_strlen(source);
 275     uint32_t tLen = u_strlen(target);
 276     char buffer[256];
 277     uint32_t len;
 278     UErrorCode status = U_ZERO_ERROR;
 279     UColAttributeValue norm = ucol_getAttribute(myCollation, UCOL_NORMALIZATION_MODE, &status);
 280
 281     UCharIterator sIter, tIter;
 282
 283     compareResult  = ucol_strcoll(myCollation, source, sLen, target, tLen);
 284     if (compareResult != result) {
 285         log_err("ucol_strcoll with explicit length returned wrong result (%i exp. %i): %s, %s\n",
 286             compareResult, result, aescstrdup(source,-1), aescstrdup(target,-1));
 287     }
 288     compareResulta = ucol_strcoll(myCollation, source, -1,   target, -1);
 289     if (compareResulta != result) {
 290         log_err("ucol_strcoll with null terminated strings returned wrong result (%i exp. %i): %s, %s\n",
 291             compareResult, result, aescstrdup(source,-1), aescstrdup(target,-1));
 292     }
 293
 294     uiter_setString(&sIter, source, sLen);
 295     uiter_setString(&tIter, target, tLen);
 296     compareResultIter = ucol_strcollIter(myCollation, &sIter, &tIter, &status);
 297     if(compareResultIter != result) {
 298         log_err("different results in iterative comparison for UTF-16 encoded strings. %s, %s\n", aescstrdup(source,-1), aescstrdup(target,-1));
 299     }
 300
 301     /* convert the strings to UTF-8 and do try comparing with char iterator and ucol_strcollUTF8 */
 302     {
 303         char utf8Source[256], utf8Target[256];
 304         int32_t utf8SourceLen = 0, utf8TargetLen = 0;
 305
 306         u_strToUTF8(utf8Source, 256, &utf8SourceLen, source, sLen, &status);
 307         if(U_FAILURE(status)) { /* probably buffer is not big enough */
 308             log_verbose("Src UTF-8 buffer too small! Will not compare!\n");
 309         } else {
 310             u_strToUTF8(utf8Target, 256, &utf8TargetLen, target, tLen, &status);
 311             if(U_SUCCESS(status)) {
 312                 {
 313                     /* ucol_strcollUTF8 */
 314                     compareResulta = ucol_strcollUTF8(myCollation, utf8Source, utf8SourceLen, utf8Target, utf8TargetLen, &status);
 315                     if (U_FAILURE(status)) {
 316                         log_err("Error in ucol_strcollUTF8 with explicit length\n");
 317                         status = U_ZERO_ERROR;
 318                     } else if (compareResulta != result) {
 319                         log_err("ucol_strcollUTF8 with explicit length returned wrong result (%i exp. %i): %s, %s\n",
 320                             compareResulta, result, aescstrdup(source,-1), aescstrdup(target,-1));
 321                     }
 322                     compareResulta = ucol_strcollUTF8(myCollation, utf8Source, -1, utf8Target, -1, &status);
 323                     if (U_FAILURE(status)) {
 324                         log_err("Error in ucol_strcollUTF8 with null terminated strings\n");
 325                         status = U_ZERO_ERROR;
 326                     } else if (compareResulta != result) {
 327                         log_err("ucol_strcollUTF8 with null terminated strings returned wrong result (%i exp. %i): %s, %s\n",
 328                             compareResulta, result, aescstrdup(source,-1), aescstrdup(target,-1));
 329                     }
 330                 }
 331
 332                 {
 333                     /* char iterator over UTF8 */
 334                     UCollationResult compareResultUTF8Iter = result, compareResultUTF8IterNorm = result;
 335
 336                     uiter_setUTF8(&sIter, utf8Source, utf8SourceLen);
 337                     uiter_setUTF8(&tIter, utf8Target, utf8TargetLen);
 338                     compareResultUTF8Iter = ucol_strcollIter(myCollation, &sIter, &tIter, &status);
 339
 340                     ucol_setAttribute(myCollation, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
 341                     sIter.move(&sIter, 0, UITER_START);
 342                     tIter.move(&tIter, 0, UITER_START);
 343                     compareResultUTF8IterNorm = ucol_strcollIter(myCollation, &sIter, &tIter, &status);
 344
 345                     ucol_setAttribute(myCollation, UCOL_NORMALIZATION_MODE, norm, &status);
 346                     if(compareResultUTF8Iter != compareResultIter) {
 347                         log_err("different results in iterative comparison for UTF-16 and UTF-8 encoded strings. %s, %s\n", aescstrdup(source,-1), aescstrdup(target,-1));
 348                     }
 349                     if(compareResultUTF8Iter != compareResultUTF8IterNorm) {
 350                         log_err("different results in iterative when normalization is turned on with UTF-8 strings. %s, %s\n", aescstrdup(source,-1), aescstrdup(target,-1));
 351                     }
 352                 }
 353             } else {
 354                 log_verbose("Target UTF-8 buffer too small! Did not compare!\n");
 355             }
 356             if(U_FAILURE(status)) {
 357                 log_verbose("UTF-8 strcoll failed! Ignoring result\n");
 358             }
 359         }
 360     }
 361
 362     /* testing the partial sortkeys */
 363     if(1) { /*!QUICK*/
 364       int32_t i = 0;
 365       int32_t partialSizes[] = { 3, 1, 2, 4, 8, 20, 80 }; /* just size 3 in the quick mode */
 366       int32_t partialSizesSize = 1;
 367       if(getTestOption(QUICK_OPTION) <= 0) {
 368         partialSizesSize = 7;
 369       }
 370       /*log_verbose("partial sortkey test piecesize=");*/
 371       for(i = 0; i < partialSizesSize; i++) {
 372         UCollationResult partialSKResult = result, partialNormalizedSKResult = result;
 373         /*log_verbose("%i ", partialSizes[i]);*/
 374
 375         partialSKResult = compareUsingPartials(myCollation, source, sLen, target, tLen, partialSizes[i], &status);
 376         if(partialSKResult != result) {
 377           log_err("Partial sortkey comparison returned wrong result (%i exp. %i): %s, %s (size %i)\n",
 378             partialSKResult, result,
 379             aescstrdup(source,-1), aescstrdup(target,-1), partialSizes[i]);
 380         }
 381
 382         if(getTestOption(QUICK_OPTION) <= 0 && norm != UCOL_ON) {
 383           /*log_verbose("N ");*/
 384           ucol_setAttribute(myCollation, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
 385           partialNormalizedSKResult = compareUsingPartials(myCollation, source, sLen, target, tLen, partialSizes[i], &status);
 386           ucol_setAttribute(myCollation, UCOL_NORMALIZATION_MODE, norm, &status);
 387           if(partialSKResult != partialNormalizedSKResult) {
 388             log_err("Partial sortkey comparison gets different result when normalization is on: %s, %s (size %i)\n",
 389               aescstrdup(source,-1), aescstrdup(target,-1), partialSizes[i]);
 390           }
 391         }
 392       }
 393       /*log_verbose("\n");*/
 394     }
 395
 396     sortklen1=ucol_getSortKey(myCollation, source, sLen,  NULL, 0);
 397     sortklen2=ucol_getSortKey(myCollation, target, tLen,  NULL, 0);
 398
 399     sortklenmax = (sortklen1>sortklen2?sortklen1:sortklen2);
 400     sortklenmin = (sortklen1<sortklen2?sortklen1:sortklen2);
 401     (void)sortklenmin;  /* Suppress set but not used warning. */
 402
 403     sortKey1 =(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
 404     sortKey1a=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
 405     ucol_getSortKey(myCollation, source, sLen, sortKey1,  sortklen1+1);
 406     ucol_getSortKey(myCollation, source, -1,   sortKey1a, sortklen1+1);
 407
 408     sortKey2 =(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
 409     sortKey2a=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
 410     ucol_getSortKey(myCollation, target, tLen, sortKey2,  sortklen2+1);
 411     ucol_getSortKey(myCollation, target, -1,   sortKey2a, sortklen2+1);
 412
 413     /* Check that sort key generated with null terminated string is identical  */
 414     /*  to that generted with a length specified.                              */
 415     if (uprv_strcmp((const char *)sortKey1, (const char *)sortKey1a) != 0 ||
 416         uprv_strcmp((const char *)sortKey2, (const char *)sortKey2a) != 0 ) {
 417         log_err("Sort Keys from null terminated and explicit length strings differ.\n");
 418     }
 419
 420     /*memcmp(sortKey1, sortKey2,sortklenmax);*/
 421     temp= uprv_strcmp((const char *)sortKey1, (const char *)sortKey2);
 422     gSortklen1 = uprv_strlen((const char *)sortKey1)+1;
 423     gSortklen2 = uprv_strlen((const char *)sortKey2)+1;
 424     if(sortklen1 != gSortklen1){
 425         log_err("SortKey length does not match Expected: %i Got: %i\n",sortklen1, gSortklen1);
 426         log_verbose("Generated sortkey: %s\n", sortKeyToString(myCollation, sortKey1, buffer, &len));
 427     }
 428     if(sortklen2!= gSortklen2){
 429         log_err("SortKey length does not match Expected: %i Got: %i\n", sortklen2, gSortklen2);
 430         log_verbose("Generated sortkey: %s\n", sortKeyToString(myCollation, sortKey2, buffer, &len));
 431     }
 432
 433     if(temp < 0) {
 434         keyResult=UCOL_LESS;
 435     }
 436     else if(temp > 0) {
 437         keyResult= UCOL_GREATER;
 438     }
 439     else {
 440         keyResult = UCOL_EQUAL;
 441     }
 442     reportCResult( source, target, sortKey1, sortKey2, compareResult, keyResult, compareResultIter, result );
 443     free(sortKey1);
 444     free(sortKey2);
 445     free(sortKey1a);
 446     free(sortKey2a);
 447
 448 }
 449
 450 void doTest(UCollator* myCollation, const UChar source[], const UChar target[], UCollationResult result)
 451 {
 452   if(myCollation) {
 453     doTestVariant(myCollation, source, target, result);
 454     if(result == UCOL_LESS) {
 455       doTestVariant(myCollation, target, source, UCOL_GREATER);
 456     } else if(result == UCOL_GREATER) {
 457       doTestVariant(myCollation, target, source, UCOL_LESS);
 458     } else {
 459       doTestVariant(myCollation, target, source, UCOL_EQUAL);
 460     }
 461   } else {
 462     log_data_err("No collator! Any data around?\n");
 463   }
 464 }
 465
 466
 467 /**
 468  * Return an integer array containing all of the collation orders
 469  * returned by calls to next on the specified iterator
 470  */
 471 OrderAndOffset* getOrders(UCollationElements *iter, int32_t *orderLength)
 472 {
 473     UErrorCode status;
 474     int32_t order;
 475     int32_t maxSize = 100;
 476     int32_t size = 0;
 477     int32_t offset = ucol_getOffset(iter);
 478     OrderAndOffset *temp;
 479     OrderAndOffset *orders =(OrderAndOffset *)malloc(sizeof(OrderAndOffset) * maxSize);
 480     status= U_ZERO_ERROR;
 481
 482
 483     while ((order=ucol_next(iter, &status)) != UCOL_NULLORDER)
 484     {
 485         if (size == maxSize)
 486         {
 487             maxSize *= 2;
 488             temp = (OrderAndOffset *)malloc(sizeof(OrderAndOffset) * maxSize);
 489
 490             memcpy(temp, orders, size * sizeof(OrderAndOffset));
 491             free(orders);
 492             orders = temp;
 493
 494         }
 495
 496         orders[size].order  = order;
 497         orders[size].offset = offset;
 498
 499         offset = ucol_getOffset(iter);
 500         size += 1;
 501     }
 502
 503     if (maxSize > size && size > 0)
 504     {
 505         temp = (OrderAndOffset *)malloc(sizeof(OrderAndOffset) * size);
 506
 507         memcpy(temp, orders, size * sizeof(OrderAndOffset));
 508         free(orders);
 509         orders = temp;
 510
 511
 512     }
 513
 514     *orderLength = size;
 515     return orders;
 516 }
 517
 518
 519 void
 520 backAndForth(UCollationElements *iter)
 521 {
 522     /* Run through the iterator forwards and stick it into an array */
 523     int32_t idx, o;
 524     UErrorCode status = U_ZERO_ERROR;
 525     int32_t orderLength = 0;
 526     OrderAndOffset *orders = getOrders(iter, &orderLength);
 527
 528
 529     /* Now go through it backwards and make sure we get the same values */
 530     idx = orderLength;
 531     ucol_reset(iter);
 532
 533     /* synwee : changed */
 534     while ((o = ucol_previous(iter, &status)) != UCOL_NULLORDER) {
 535 #if TEST_OFFSETS
 536       int32_t offset =
 537 #endif
 538         ucol_getOffset(iter);
 539
 540       idx -= 1;
 541       if (o != orders[idx].order) {
 542         if (o == 0)
 543           idx ++;
 544         else {
 545           while (idx > 0 && orders[-- idx].order == 0) {
 546             /* nothing... */
 547           }
 548
 549           if (o != orders[idx].order) {
 550               log_err("Mismatched order at index %d: 0x%8.8X vs. 0x%8.8X\n", idx,
 551                 orders[idx].order, o);
 552             goto bail;
 553           }
 554         }
 555       }
 556
 557 #if TEST_OFFSETS
 558       if (offset != orders[idx].offset) {
 559         log_err("Mismatched offset at index %d: %d vs. %d\n", idx,
 560             orders[idx].offset, offset);
 561         goto bail;
 562       }
 563 #endif
 564
 565     }
 566
 567     while (idx != 0 && orders[idx - 1].order == 0) {
 568       idx -= 1;
 569     }
 570
 571     if (idx != 0) {
 572         log_err("Didn't get back to beginning - index is %d\n", idx);
 573
 574         ucol_reset(iter);
 575         log_err("\nnext: ");
 576
 577         if ((o = ucol_next(iter, &status)) != UCOL_NULLORDER) {
 578             log_err("Error at %x\n", o);
 579         }
 580
 581         log_err("\nprev: ");
 582
 583         if ((o = ucol_previous(iter, &status)) != UCOL_NULLORDER) {
 584             log_err("Error at %x\n", o);
 585         }
 586
 587         log_verbose("\n");
 588     }
 589
 590 bail:
 591     free(orders);
 592 }
 593
 594 void genericOrderingTestWithResult(UCollator *coll, const char * const s[], uint32_t size, UCollationResult result) {
 595   UChar t1[2048] = {0};
 596   UChar t2[2048] = {0};
 597   UCollationElements *iter;
 598   UErrorCode status = U_ZERO_ERROR;
 599
 600   uint32_t i = 0, j = 0;
 601   log_verbose("testing sequence:\n");
 602   for(i = 0; i < size; i++) {
 603     log_verbose("%s\n", s[i]);
 604   }
 605
 606   iter = ucol_openElements(coll, t1, u_strlen(t1), &status);
 607   if (U_FAILURE(status)) {
 608     log_err("Creation of iterator failed\n");
 609   }
 610   for(i = 0; i < size-1; i++) {
 611     for(j = i+1; j < size; j++) {
 612       u_unescape(s[i], t1, 2048);
 613       u_unescape(s[j], t2, 2048);
 614       doTest(coll, t1, t2, result);
 615       /* synwee : added collation element iterator test */
 616       ucol_setText(iter, t1, u_strlen(t1), &status);
 617       backAndForth(iter);
 618       ucol_setText(iter, t2, u_strlen(t2), &status);
 619       backAndForth(iter);
 620     }
 621   }
 622   ucol_closeElements(iter);
 623 }
 624
 625 void genericOrderingTest(UCollator *coll, const char * const s[], uint32_t size) {
 626   genericOrderingTestWithResult(coll, s, size, UCOL_LESS);
 627 }
 628
 629 void genericLocaleStarter(const char *locale, const char * const s[], uint32_t size) {
 630   UErrorCode status = U_ZERO_ERROR;
 631   UCollator *coll = ucol_open(locale, &status);
 632
 633   log_verbose("Locale starter for %s\n", locale);
 634
 635   if(U_SUCCESS(status)) {
 636     genericOrderingTest(coll, s, size);
 637   } else if(status == U_FILE_ACCESS_ERROR) {
 638     log_data_err("Is your data around?\n");
 639     return;
 640   } else {
 641     log_err("Unable to open collator for locale %s\n", locale);
 642   }
 643   ucol_close(coll);
 644 }
 645
 646 void genericLocaleStarterWithResult(const char *locale, const char * const s[], uint32_t size, UCollationResult result) {
 647   UErrorCode status = U_ZERO_ERROR;
 648   UCollator *coll = ucol_open(locale, &status);
 649
 650   log_verbose("Locale starter for %s\n", locale);
 651
 652   if(U_SUCCESS(status)) {
 653     genericOrderingTestWithResult(coll, s, size, result);
 654   } else if(status == U_FILE_ACCESS_ERROR) {
 655     log_data_err("Is your data around?\n");
 656     return;
 657   } else {
 658     log_err("Unable to open collator for locale %s\n", locale);
 659   }
 660   ucol_close(coll);
 661 }
 662
 663 /* currently not used with options */
 664 void genericRulesStarterWithOptionsAndResult(const char *rules, const char * const s[], uint32_t size, const UColAttribute *attrs, const UColAttributeValue *values, uint32_t attsize, UCollationResult result) {
 665   UErrorCode status = U_ZERO_ERROR;
 666   UChar rlz[RULE_BUFFER_LEN] = { 0 };
 667   uint32_t rlen = u_unescape(rules, rlz, RULE_BUFFER_LEN);
 668   uint32_t i;
 669
 670   UCollator *coll = ucol_openRules(rlz, rlen, UCOL_DEFAULT, UCOL_DEFAULT,NULL, &status);
 671
 672   log_verbose("Rules starter for %s\n", rules);
 673
 674   if(U_SUCCESS(status)) {
 675     log_verbose("Setting attributes\n");
 676     for(i = 0; i < attsize; i++) {
 677       ucol_setAttribute(coll, attrs[i], values[i], &status);
 678     }
 679
 680     genericOrderingTestWithResult(coll, s, size, result);
 681   } else {
 682     log_err_status(status, "Unable to open collator with rules %s\n", rules);
 683   }
 684   ucol_close(coll);
 685 }
 686
 687 void genericLocaleStarterWithOptionsAndResult(const char *locale, const char * const s[], uint32_t size, const UColAttribute *attrs, const UColAttributeValue *values, uint32_t attsize, UCollationResult result) {
 688   UErrorCode status = U_ZERO_ERROR;
 689   uint32_t i;
 690
 691   UCollator *coll = ucol_open(locale, &status);
 692
 693   log_verbose("Locale starter for %s\n", locale);
 694
 695   if(U_SUCCESS(status)) {
 696
 697     log_verbose("Setting attributes\n");
 698     for(i = 0; i < attsize; i++) {
 699       ucol_setAttribute(coll, attrs[i], values[i], &status);
 700     }
 701
 702     genericOrderingTestWithResult(coll, s, size, result);
 703   } else {
 704     log_err_status(status, "Unable to open collator for locale %s\n", locale);
 705   }
 706   ucol_close(coll);
 707 }
 708
 709 void genericLocaleStarterWithOptions(const char *locale, const char * const s[], uint32_t size, const UColAttribute *attrs, const UColAttributeValue *values, uint32_t attsize) {
 710   genericLocaleStarterWithOptionsAndResult(locale, s, size, attrs, values, attsize, UCOL_LESS);
 711 }
 712
 713 void genericRulesStarterWithResult(const char *rules, const char * const s[], uint32_t size, UCollationResult result) {
 714   UErrorCode status = U_ZERO_ERROR;
 715   UChar rlz[RULE_BUFFER_LEN] = { 0 };
 716   uint32_t rlen = u_unescape(rules, rlz, RULE_BUFFER_LEN);
 717
 718   UCollator *coll = NULL;
 719   coll = ucol_openRules(rlz, rlen, UCOL_DEFAULT, UCOL_DEFAULT,NULL, &status);
 720   log_verbose("Rules starter for %s\n", rules);
 721
 722   if(U_SUCCESS(status)) {
 723     genericOrderingTestWithResult(coll, s, size, result);
 724     ucol_close(coll);
 725   } else if(status == U_FILE_ACCESS_ERROR) {
 726     log_data_err("Is your data around?\n");
 727   } else {
 728     log_err("Unable to open collator with rules %s\n", rules);
 729   }
 730 }
 731
 732 void genericRulesStarter(const char *rules, const char * const s[], uint32_t size) {
 733   genericRulesStarterWithResult(rules, s, size, UCOL_LESS);
 734 }
 735
 736 static void TestTertiary()
 737 {
 738     int32_t len,i;
 739     UCollator *myCollation;
 740     UErrorCode status=U_ZERO_ERROR;
 741     static const char str[]="& C < ch, cH, Ch, CH & Five, 5 & Four, 4 & one, 1 & Ampersand; '&' & Two, 2 ";
 742     UChar rules[sizeof(str)];
 743     len = strlen(str);
 744     u_uastrcpy(rules, str);
 745
 746     myCollation=ucol_openRules(rules, len, UCOL_OFF, UCOL_DEFAULT_STRENGTH, NULL, &status);
 747     if(U_FAILURE(status)){
 748         log_err_status(status, "ERROR: in creation of rule based collator :%s\n", myErrorName(status));
 749         return;
 750     }
 751
 752     ucol_setStrength(myCollation, UCOL_TERTIARY);
 753     for (i = 0; i < 17 ; i++)
 754     {
 755         doTest(myCollation, testSourceCases[i], testTargetCases[i], results[i]);
 756     }
 757     ucol_close(myCollation);
 758     myCollation = 0;
 759 }
 760
 761 static void TestPrimary( )
 762 {
 763     int32_t len,i;
 764     UCollator *myCollation;
 765     UErrorCode status=U_ZERO_ERROR;
 766     static const char str[]="& C < ch, cH, Ch, CH & Five, 5 & Four, 4 & one, 1 & Ampersand; '&' & Two, 2 ";
 767     UChar rules[sizeof(str)];
 768     len = strlen(str);
 769     u_uastrcpy(rules, str);
 770
 771     myCollation=ucol_openRules(rules, len, UCOL_OFF, UCOL_DEFAULT_STRENGTH,NULL, &status);
 772     if(U_FAILURE(status)){
 773         log_err_status(status, "ERROR: in creation of rule based collator :%s\n", myErrorName(status));
 774         return;
 775     }
 776     ucol_setStrength(myCollation, UCOL_PRIMARY);
 777
 778     for (i = 17; i < 26 ; i++)
 779     {
 780
 781         doTest(myCollation, testSourceCases[i], testTargetCases[i], results[i]);
 782     }
 783     ucol_close(myCollation);
 784     myCollation = 0;
 785 }
 786
 787 static void TestSecondary()
 788 {
 789     int32_t i;
 790     int32_t len;
 791     UCollator *myCollation;
 792     UErrorCode status=U_ZERO_ERROR;
 793     static const char str[]="& C < ch, cH, Ch, CH & Five, 5 & Four, 4 & one, 1 & Ampersand; '&' & Two, 2 ";
 794     UChar rules[sizeof(str)];
 795     len = strlen(str);
 796     u_uastrcpy(rules, str);
 797
 798     myCollation=ucol_openRules(rules, len, UCOL_OFF, UCOL_DEFAULT_STRENGTH,NULL, &status);
 799     if(U_FAILURE(status)){
 800         log_err_status(status, "ERROR: in creation of rule based collator :%s\n", myErrorName(status));
 801         return;
 802     }
 803     ucol_setStrength(myCollation, UCOL_SECONDARY);
 804     for (i = 26; i < 34 ; i++)
 805     {
 806         doTest(myCollation, testSourceCases[i], testTargetCases[i], results[i]);
 807     }
 808     ucol_close(myCollation);
 809     myCollation = 0;
 810 }
 811
 812 static void TestIdentical()
 813 {
 814     int32_t i;
 815     int32_t len;
 816     UCollator *myCollation;
 817     UErrorCode status=U_ZERO_ERROR;
 818     static const char str[]="& C < ch, cH, Ch, CH & Five, 5 & Four, 4 & one, 1 & Ampersand; '&' & Two, 2 ";
 819     UChar rules[sizeof(str)];
 820     len = strlen(str);
 821     u_uastrcpy(rules, str);
 822
 823     myCollation=ucol_openRules(rules, len, UCOL_OFF, UCOL_IDENTICAL, NULL,&status);
 824     if(U_FAILURE(status)){
 825         log_err_status(status, "ERROR: in creation of rule based collator :%s\n", myErrorName(status));
 826         return;
 827     }
 828     for(i= 34; i<37; i++)
 829     {
 830         doTest(myCollation, testSourceCases[i], testTargetCases[i], results[i]);
 831     }
 832     ucol_close(myCollation);
 833     myCollation = 0;
 834 }
 835
 836 static void TestExtra()
 837 {
 838     int32_t i, j;
 839     int32_t len;
 840     UCollator *myCollation;
 841     UErrorCode status = U_ZERO_ERROR;
 842     static const char str[]="& C < ch, cH, Ch, CH & Five, 5 & Four, 4 & one, 1 & Ampersand; '&' & Two, 2 ";
 843     UChar rules[sizeof(str)];
 844     len = strlen(str);
 845     u_uastrcpy(rules, str);
 846
 847     myCollation=ucol_openRules(rules, len, UCOL_OFF, UCOL_DEFAULT_STRENGTH,NULL, &status);
 848     if(U_FAILURE(status)){
 849         log_err_status(status, "ERROR: in creation of rule based collator :%s\n", myErrorName(status));
 850         return;
 851     }
 852     ucol_setStrength(myCollation, UCOL_TERTIARY);
 853     for (i = 0; i < COUNT_TEST_CASES-1 ; i++)
 854     {
 855         for (j = i + 1; j < COUNT_TEST_CASES; j += 1)
 856         {
 857
 858             doTest(myCollation, testCases[i], testCases[j], UCOL_LESS);
 859         }
 860     }
 861     ucol_close(myCollation);
 862     myCollation = 0;
 863 }
 864
 865 static void TestJB581(void)
 866 {
 867     int32_t     bufferLen   = 0;
 868     UChar       source      [100];
 869     UChar       target      [100];
 870     UCollationResult result     = UCOL_EQUAL;
 871     uint8_t     sourceKeyArray  [100];
 872     uint8_t     targetKeyArray  [100];
 873     int32_t     sourceKeyOut    = 0,
 874                 targetKeyOut    = 0;
 875     UCollator   *myCollator = 0;
 876     UErrorCode status = U_ZERO_ERROR;
 877
 878     /*u_uastrcpy(source, "This is a test.");*/
 879     /*u_uastrcpy(target, "THISISATEST.");*/
 880     u_uastrcpy(source, "THISISATEST.");
 881     u_uastrcpy(target, "Thisisatest.");
 882
 883     myCollator = ucol_open("en_US", &status);
 884     if (U_FAILURE(status)){
 885         log_err_status(status, "ERROR: Failed to create the collator : %s\n", u_errorName(status));
 886         return;
 887     }
 888     result = ucol_strcoll(myCollator, source, -1, target, -1);
 889     /* result is 1, secondary differences only for ignorable space characters*/
 890     if (result != 1)
 891     {
 892         log_err("Comparing two strings with only secondary differences in C failed.\n");
 893     }
 894     /* To compare them with just primary differences */
 895     ucol_setStrength(myCollator, UCOL_PRIMARY);
 896     result = ucol_strcoll(myCollator, source, -1, target, -1);
 897     /* result is 0 */
 898     if (result != 0)
 899     {
 900         log_err("Comparing two strings with no differences in C failed.\n");
 901     }
 902     /* Now, do the same comparison with keys */
 903     sourceKeyOut = ucol_getSortKey(myCollator, source, -1, sourceKeyArray, 100);
 904     (void)sourceKeyOut;    /* Suppress set but not used warning. */
 905     targetKeyOut = ucol_getSortKey(myCollator, target, -1, targetKeyArray, 100);
 906     bufferLen = ((targetKeyOut > 100) ? 100 : targetKeyOut);
 907     if (memcmp(sourceKeyArray, targetKeyArray, bufferLen) != 0)
 908     {
 909         log_err("Comparing two strings with sort keys in C failed.\n");
 910     }
 911     ucol_close(myCollator);
 912 }
 913
 914 static void TestJB1401(void)
 915 {
 916     UCollator     *myCollator = 0;
 917     UErrorCode     status = U_ZERO_ERROR;
 918     static UChar   NFD_UnsafeStartChars[] = {
 919         0x0f73,          /* Tibetan Vowel Sign II */
 920         0x0f75,          /* Tibetan Vowel Sign UU */
 921         0x0f81,          /* Tibetan Vowel Sign Reversed II */
 922             0
 923     };
 924     int            i;
 925
 926
 927     myCollator = ucol_open("en_US", &status);
 928     if (U_FAILURE(status)){
 929         log_err_status(status, "ERROR: Failed to create the collator : %s\n", u_errorName(status));
 930         return;
 931     }
 932     ucol_setAttribute(myCollator, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
 933     if (U_FAILURE(status)){
 934         log_err("ERROR: Failed to set normalization mode ON for collator.\n");
 935         return;
 936     }
 937
 938     for (i=0; ; i++) {
 939         UChar    c;
 940         UChar    X[4];
 941         UChar    Y[20];
 942         UChar    Z[20];
 943
 944         /*  Get the next funny character to be tested, and set up the
 945          *  three test strings X, Y, Z, consisting of an A-grave + test char,
 946          *    in original form, NFD, and then NFC form.
 947          */
 948         c = NFD_UnsafeStartChars[i];
 949         if (c==0) {break;}
 950
 951         X[0]=0xC0; X[1]=c; X[2]=0;   /* \u00C0 is A Grave*/
 952
 953         unorm_normalize(X, -1, UNORM_NFD, 0, Y, 20, &status);
 954         unorm_normalize(Y, -1, UNORM_NFC, 0, Z, 20, &status);
 955         if (U_FAILURE(status)){
 956             log_err("ERROR: Failed to normalize test of character %x\n", c);
 957             return;
 958         }
 959
 960         /* Collation test.  All three strings should be equal.
 961          *   doTest does both strcoll and sort keys, with params in both orders.
 962          */
 963         doTest(myCollator, X, Y, UCOL_EQUAL);
 964         doTest(myCollator, X, Z, UCOL_EQUAL);
 965         doTest(myCollator, Y, Z, UCOL_EQUAL);
 966
 967         /* Run collation element iterators over the three strings.  Results should be same for each.
 968          */
 969         {
 970             UCollationElements *ceiX, *ceiY, *ceiZ;
 971             int32_t             ceX,   ceY,   ceZ;
 972             int                 j;
 973
 974             ceiX = ucol_openElements(myCollator, X, -1, &status);
 975             ceiY = ucol_openElements(myCollator, Y, -1, &status);
 976             ceiZ = ucol_openElements(myCollator, Z, -1, &status);
 977             if (U_FAILURE(status)) {
 978                 log_err("ERROR: uucol_openElements failed.\n");
 979                 return;
 980             }
 981
 982             for (j=0;; j++) {
 983                 ceX = ucol_next(ceiX, &status);
 984                 ceY = ucol_next(ceiY, &status);
 985                 ceZ = ucol_next(ceiZ, &status);
 986                 if (U_FAILURE(status)) {
 987                     log_err("ERROR: ucol_next failed for iteration #%d.\n", j);
 988                     break;
 989                 }
 990                 if (ceX != ceY || ceY != ceZ) {
 991                     log_err("ERROR: ucol_next failed for iteration #%d.\n", j);
 992                     break;
 993                 }
 994                 if (ceX == UCOL_NULLORDER) {
 995                     break;
 996                 }
 997             }
 998             ucol_closeElements(ceiX);
 999             ucol_closeElements(ceiY);
1000             ucol_closeElements(ceiZ);
1001         }
1002     }
1003     ucol_close(myCollator);
1004 }
1005
1006
1007
1008 /**
1009 * Tests the [variable top] tag in rule syntax. Since the default [alternate]
1010 * tag has the value shifted, any codepoints before [variable top] should give
1011 * a primary ce of 0.
1012 */
1013 static void TestVariableTop(void)
1014 {
1015 #if 0
1016     /*
1017      * Starting with ICU 53, setting the variable top via a pseudo relation string
1018      * is not supported any more.
1019      * It was replaced by the [maxVariable symbol] setting.
1020      * See ICU tickets #9958 and #8032.
1021      */
1022     static const char       str[]          = "&z = [variable top]";
1023           int         len          = strlen(str);
1024           UChar      rules[sizeof(str)];
1025           UCollator  *myCollation;
1026           UCollator  *enCollation;
1027           UErrorCode  status       = U_ZERO_ERROR;
1028           UChar       source[1];
1029           UChar       ch;
1030           uint8_t     result[20];
1031           uint8_t     expected[20];
1032
1033     u_uastrcpy(rules, str);
1034
1035     enCollation = ucol_open("en_US", &status);
1036     if (U_FAILURE(status)) {
1037         log_err_status(status, "ERROR: in creation of collator :%s\n",
1038                 myErrorName(status));
1039         return;
1040     }
1041     myCollation = ucol_openRules(rules, len, UCOL_OFF,
1042                                  UCOL_PRIMARY,NULL, &status);
1043     if (U_FAILURE(status)) {
1044         ucol_close(enCollation);
1045         log_err("ERROR: in creation of rule based collator :%s\n",
1046                 myErrorName(status));
1047         return;
1048     }
1049
1050     ucol_setStrength(enCollation, UCOL_PRIMARY);
1051     ucol_setAttribute(enCollation, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED,
1052                       &status);
1053     ucol_setAttribute(myCollation, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED,
1054                       &status);
1055
1056     if (ucol_getAttribute(myCollation, UCOL_ALTERNATE_HANDLING, &status) !=
1057         UCOL_SHIFTED || U_FAILURE(status)) {
1058         log_err("ERROR: ALTERNATE_HANDLING value can not be set to SHIFTED\n");
1059     }
1060
1061     uprv_memset(expected, 0, 20);
1062
1063     /* space is supposed to be a variable */
1064     source[0] = ' ';
1065     len = ucol_getSortKey(enCollation, source, 1, result,
1066                           sizeof(result));
1067
1068     if (uprv_memcmp(expected, result, len) != 0) {
1069         log_err("ERROR: SHIFTED alternate does not return 0 for primary of space\n");
1070     }
1071
1072     ch = 'a';
1073     while (ch < 'z') {
1074         source[0] = ch;
1075         len = ucol_getSortKey(myCollation, source, 1, result,
1076                               sizeof(result));
1077         if (uprv_memcmp(expected, result, len) != 0) {
1078             log_err("ERROR: SHIFTED alternate does not return 0 for primary of %c\n",
1079                     ch);
1080         }
1081         ch ++;
1082     }
1083
1084     ucol_close(enCollation);
1085     ucol_close(myCollation);
1086     enCollation = NULL;
1087     myCollation = NULL;
1088 #endif
1089 }
1090
1091 /**
1092   * Tests surrogate support.
1093   * NOTE: This test used \\uD801\\uDC01 pair, which is now assigned to Desseret
1094   * Therefore, another (unassigned) code point was used for this test.
1095   */
1096 static void TestSurrogates(void)
1097 {
1098     static const char       str[]          =
1099                               "&z<'\\uD800\\uDC00'<'\\uD800\\uDC0A\\u0308'<A";
1100           int         len          = strlen(str);
1101           int         rlen         = 0;
1102           UChar      rules[sizeof(str)];
1103           UCollator  *myCollation;
1104           UCollator  *enCollation;
1105           UErrorCode  status       = U_ZERO_ERROR;
1106           UChar       source[][4]    =
1107           {{'z', 0, 0}, {0xD800, 0xDC00, 0}, {0xD800, 0xDC0A, 0x0308, 0}, {0xD800, 0xDC02}};
1108           UChar       target[][4]    =
1109           {{0xD800, 0xDC00, 0}, {0xD800, 0xDC0A, 0x0308, 0}, {'A', 0, 0}, {0xD800, 0xDC03}};
1110           int         count        = 0;
1111           uint8_t enresult[20], myresult[20];
1112           int enlen, mylen;
1113
1114     /* tests for open rules with surrogate rules */
1115     rlen = u_unescape(str, rules, len);
1116
1117     enCollation = ucol_open("en_US", &status);
1118     if (U_FAILURE(status)) {
1119         log_err_status(status, "ERROR: in creation of collator :%s\n",
1120                 myErrorName(status));
1121         return;
1122     }
1123     myCollation = ucol_openRules(rules, rlen, UCOL_OFF,
1124                                  UCOL_TERTIARY,NULL, &status);
1125     if (U_FAILURE(status)) {
1126         ucol_close(enCollation);
1127         log_err("ERROR: in creation of rule based collator :%s\n",
1128                 myErrorName(status));
1129         return;
1130     }
1131
1132     /*
1133     this test is to verify the supplementary sort key order in the english
1134     collator
1135     */
1136     log_verbose("start of english collation supplementary characters test\n");
1137     while (count < 2) {
1138         doTest(enCollation, source[count], target[count], UCOL_LESS);
1139         count ++;
1140     }
1141     doTest(enCollation, source[count], target[count], UCOL_GREATER);
1142
1143     log_verbose("start of tailored collation supplementary characters test\n");
1144     count = 0;
1145     /* tests getting collation elements for surrogates for tailored rules */
1146     while (count < 4) {
1147         doTest(myCollation, source[count], target[count], UCOL_LESS);
1148         count ++;
1149     }
1150
1151     /* tests that \uD800\uDC02 still has the same value, not changed */
1152     enlen = ucol_getSortKey(enCollation, source[3], 2, enresult, 20);
1153     mylen = ucol_getSortKey(myCollation, source[3], 2, myresult, 20);
1154     if (enlen != mylen ||
1155         uprv_memcmp(enresult, myresult, enlen) != 0) {
1156         log_verbose("Failed : non-tailored supplementary characters should have the same value\n");
1157     }
1158
1159     ucol_close(enCollation);
1160     ucol_close(myCollation);
1161     enCollation = NULL;
1162     myCollation = NULL;
1163 }
1164
1165 /*
1166  *### TODO: Add more invalid rules to test all different scenarios.
1167  *
1168  */
1169 static void
1170 TestInvalidRules(){
1171 #define MAX_ERROR_STATES 2
1172
1173     static const char* rulesArr[MAX_ERROR_STATES] = {
1174         "& C < ch, cH, Ch[this should fail]<d",
1175         "& C < ch, cH, & Ch[variable top]"
1176     };
1177     static const char* preContextArr[MAX_ERROR_STATES] = {
1178         " C < ch, cH, Ch",
1179         "& C < ch, cH",
1180
1181     };
1182     static const char* postContextArr[MAX_ERROR_STATES] = {
1183         "[this should fa",
1184         ", & Ch[variable"
1185     };
1186     int i;
1187
1188     for(i = 0;i<MAX_ERROR_STATES;i++){
1189         UChar rules[1000]       = { '\0' };
1190         UChar preContextExp[1000]  = { '\0' };
1191         UChar postContextExp[1000] = { '\0' };
1192         UParseError parseError;
1193         UErrorCode status = U_ZERO_ERROR;
1194         UCollator* coll=0;
1195         u_charsToUChars(rulesArr[i],rules,uprv_strlen(rulesArr[i])+1);
1196         u_charsToUChars(preContextArr[i],preContextExp,uprv_strlen(preContextArr[i])+1);
1197         u_charsToUChars(postContextArr[i],postContextExp,uprv_strlen(postContextArr[i])+1);
1198         /* clean up stuff in parseError */
1199         u_memset(parseError.preContext,0x0000,U_PARSE_CONTEXT_LEN);
1200         u_memset(parseError.postContext,0x0000,U_PARSE_CONTEXT_LEN);
1201         /* open the rules and test */
1202         coll = ucol_openRules(rules,u_strlen(rules),UCOL_OFF,UCOL_DEFAULT_STRENGTH,&parseError,&status);
1203         (void)coll;   /* Suppress set but not used warning. */
1204         if(u_strcmp(parseError.preContext,preContextExp)!=0){
1205             log_err_status(status, "preContext in UParseError for ucol_openRules does not match: \"%s\"\n",
1206                            aescstrdup(parseError.preContext, -1));
1207         }
1208         if(u_strcmp(parseError.postContext,postContextExp)!=0){
1209             log_err_status(status, "postContext in UParseError for ucol_openRules does not match: \"%s\"\n",
1210                            aescstrdup(parseError.postContext, -1));
1211         }
1212     }
1213 }
1214
1215 static void
1216 TestJitterbug1098(){
1217     UChar rule[1000];
1218     UCollator* c1 = NULL;
1219     UErrorCode status = U_ZERO_ERROR;
1220     UParseError parseError;
1221     char preContext[200]={0};
1222     char postContext[200]={0};
1223     int i=0;
1224     const char* rules[] = {
1225          "&''<\\\\",
1226          "&\\'<\\\\",
1227          "&\\\"<'\\'",
1228          "&'\"'<\\'",
1229          NULL
1230
1231     };
1232     const UCollationResult results1098[] = {
1233         UCOL_LESS,
1234         UCOL_LESS,
1235         UCOL_LESS,
1236         UCOL_LESS,
1237     };
1238     const UChar input[][2]= {
1239         {0x0027,0x005c},
1240         {0x0027,0x005c},
1241         {0x0022,0x005c},
1242         {0x0022,0x0027},
1243     };
1244     UChar X[2] ={0};
1245     UChar Y[2] ={0};
1246     u_memset(parseError.preContext,0x0000,U_PARSE_CONTEXT_LEN);
1247     u_memset(parseError.postContext,0x0000,U_PARSE_CONTEXT_LEN);
1248     for(;rules[i]!=0;i++){
1249         u_uastrcpy(rule, rules[i]);
1250         c1 = ucol_openRules(rule, u_strlen(rule), UCOL_OFF, UCOL_DEFAULT_STRENGTH, &parseError, &status);
1251         if(U_FAILURE(status)){
1252             log_err_status(status, "Could not parse the rules syntax. Error: %s\n", u_errorName(status));
1253
1254             if (status == U_PARSE_ERROR) {
1255                 u_UCharsToChars(parseError.preContext,preContext,20);
1256                 u_UCharsToChars(parseError.postContext,postContext,20);
1257                 log_verbose("\n\tPre-Context: %s \n\tPost-Context:%s \n",preContext,postContext);
1258             }
1259
1260             return;
1261         }
1262         X[0] = input[i][0];
1263         Y[0] = input[i][1];
1264         doTest(c1,X,Y,results1098[i]);
1265         ucol_close(c1);
1266     }
1267 }
1268
1269 static void
1270 TestFCDCrash(void) {
1271     static const char *test[] = {
1272     "Gr\\u00F6\\u00DFe",
1273     "Grossist"
1274     };
1275
1276     UErrorCode status = U_ZERO_ERROR;
1277     UCollator *coll = ucol_open("es", &status);
1278     if(U_FAILURE(status)) {
1279         log_err_status(status, "Couldn't open collator -> %s\n", u_errorName(status));
1280         return;
1281     }
1282     ucol_close(coll);
1283     coll = NULL;
1284     ctest_resetICU();
1285     coll = ucol_open("de_DE", &status);
1286     if(U_FAILURE(status)) {
1287         log_err_status(status, "Couldn't open collator -> %s\n", u_errorName(status));
1288         return;
1289     }
1290     ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
1291     genericOrderingTest(coll, test, 2);
1292     ucol_close(coll);
1293 }
1294
1295 /*static UBool
1296 find(UEnumeration* list, const char* str, UErrorCode* status){
1297     const char* value = NULL;
1298     int32_t length=0;
1299     if(U_FAILURE(*status)){
1300         return FALSE;
1301     }
1302     uenum_reset(list, status);
1303     while( (value= uenum_next(list, &length, status))!=NULL){
1304         if(strcmp(value, str)==0){
1305             return TRUE;
1306         }
1307     }
1308     return FALSE;
1309 }*/
1310
1311 static void TestJ5298(void)
1312 {
1313     UErrorCode status = U_ZERO_ERROR;
1314     char input[256], output[256];
1315     UBool isAvailable;
1316     int32_t i = 0;
1317     UEnumeration* values = NULL;
1318     const char *keywordValue = NULL;
1319     log_verbose("Number of collator locales returned : %i \n", ucol_countAvailable());
1320     values = ucol_getKeywordValues("collation", &status);
1321     while ((keywordValue = uenum_next(values, NULL, &status)) != NULL) {
1322         if (strncmp(keywordValue, "private-", 8) == 0) {
1323             log_err("ucol_getKeywordValues() returns private collation keyword: %s\n", keywordValue);
1324         }
1325     }
1326     for (i = 0; i < ucol_countAvailable(); i++) {
1327         uenum_reset(values, &status);
1328         while ((keywordValue = uenum_next(values, NULL, &status)) != NULL) {
1329             strcpy(input, ucol_getAvailable(i));
1330             if (strcmp(keywordValue, "standard") != 0) {
1331                 strcat(input, "@collation=");
1332                 strcat(input, keywordValue);
1333             }
1334
1335             ucol_getFunctionalEquivalent(output, 256, "collation", input, &isAvailable, &status);
1336             if (strcmp(input, output) == 0) { /* Unique locale, print it out */
1337                 log_verbose("%s, \n", output);
1338             }
1339         }
1340     }
1341     uenum_close(values);
1342     log_verbose("\n");
1343 }
1344 #endif /* #if !UCONFIG_NO_COLLATION */