icuSources/test/cintltst/callcoll.c

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